trunks: fix power_manager tests to use generated mock

This prevents fragility when the D-Bus interface for power_manager
changes. Instead of keeping a separate header that has to be
updated in lockstep, just incorporate the libpower_manager-client-test
package so we have access to a generated mock.

BUG=chromium:735764
TEST=unit tests

Change-Id: Ieb45bd9f3b7a916dc288657bdba043eed243a29a
Reviewed-on: https://chromium-review.googlesource.com/546336
Commit-Ready: Eric Caruso <ejcaruso@chromium.org>
Tested-by: Eric Caruso <ejcaruso@chromium.org>
Reviewed-by: Dan Erat <derat@chromium.org>
diff --git a/trunks/mock_power_manager_proxy.h b/trunks/mock_power_manager_proxy.h
deleted file mode 100644
index f37627a..0000000
--- a/trunks/mock_power_manager_proxy.h
+++ /dev/null
@@ -1,286 +0,0 @@
-//
-// Copyright (C) 2017 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef TRUNKS_MOCK_POWER_MANAGER_PROXY_H_
-#define TRUNKS_MOCK_POWER_MANAGER_PROXY_H_
-
-#include <gmock/gmock.h>
-#include <power_manager-client/power_manager/dbus-proxies.h>
-
-namespace trunks {
-
-class MockPowerManagerProxy : public org::chromium::PowerManagerProxyInterface {
- public:
-  MockPowerManagerProxy(dbus::ObjectProxy* object_proxy = nullptr)
-    : object_proxy_(object_proxy) {}
-
-  void set_object_proxy(dbus::ObjectProxy* object_proxy) {
-    object_proxy_ = object_proxy;
-  }
-
-  dbus::ObjectProxy* GetObjectProxy() const { return object_proxy_; }
-
-  MOCK_CONST_METHOD0(GetObjectPath,
-                     const dbus::ObjectPath&());
-  MOCK_METHOD2(RequestShutdown,
-               bool(brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD3(RequestShutdownAsync,
-               void(const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(RequestRestart,
-               bool(int32_t,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(RequestRestartAsync,
-               void(int32_t,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(RequestSuspend,
-               bool(uint64_t,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(RequestSuspendAsync,
-               void(uint64_t,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(DecreaseScreenBrightness,
-               bool(bool,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(DecreaseScreenBrightnessAsync,
-               void(bool,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD2(IncreaseScreenBrightness,
-               bool(brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD3(IncreaseScreenBrightnessAsync,
-               void(const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(GetScreenBrightnessPercent,
-               bool(double*,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD3(GetScreenBrightnessPercentAsync,
-               void(const base::Callback<void(double)>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD4(SetScreenBrightnessPercent,
-               bool(double,
-                    int32_t,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD5(SetScreenBrightnessPercentAsync,
-               void(double,
-                    int32_t,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD2(DecreaseKeyboardBrightness,
-               bool(brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD3(DecreaseKeyboardBrightnessAsync,
-               void(const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD2(IncreaseKeyboardBrightness,
-               bool(brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD3(IncreaseKeyboardBrightnessAsync,
-               void(const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(GetPowerSupplyProperties,
-               bool(std::vector<uint8_t>*,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD3(GetPowerSupplyPropertiesAsync,
-               void(const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(HandleVideoActivity,
-               bool(bool,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(HandleVideoActivityAsync,
-               void(bool,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(HandleUserActivity,
-               bool(int32_t,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(HandleUserActivityAsync,
-               void(int32_t,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(SetIsProjecting,
-               bool(bool,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(SetIsProjectingAsync,
-               void(bool,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(SetPolicy,
-               bool(const std::vector<uint8_t>&,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(SetPolicyAsync,
-               void(const std::vector<uint8_t>&,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(SetPowerSource,
-               bool(const std::string&,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(SetPowerSourceAsync,
-               void(const std::string&,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(HandlePowerButtonAcknowledgment,
-               bool(int64_t,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(HandlePowerButtonAcknowledgmentAsync,
-               void(int64_t,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(IgnoreNextPowerButtonPress,
-               bool(int64_t,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(IgnoreNextPowerButtonPressAsync,
-               void(int64_t,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD4(RegisterSuspendDelay,
-               bool(const std::vector<uint8_t>&,
-                    std::vector<uint8_t>*,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(RegisterSuspendDelayAsync,
-               void(const std::vector<uint8_t>&,
-                    const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(UnregisterSuspendDelay,
-               bool(const std::vector<uint8_t>&,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(UnregisterSuspendDelayAsync,
-               void(const std::vector<uint8_t>&,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(HandleSuspendReadiness,
-               bool(const std::vector<uint8_t>&,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(HandleSuspendReadinessAsync,
-               void(const std::vector<uint8_t>&,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD4(RegisterDarkSuspendDelay,
-               bool(const std::vector<uint8_t>&,
-                    std::vector<uint8_t>*,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(RegisterDarkSuspendDelayAsync,
-               void(const std::vector<uint8_t>&,
-                    const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(UnregisterDarkSuspendDelay,
-               bool(const std::vector<uint8_t>&,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(UnregisterDarkSuspendDelayAsync,
-               void(const std::vector<uint8_t>&,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(HandleDarkSuspendReadiness,
-               bool(const std::vector<uint8_t>&,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(HandleDarkSuspendReadinessAsync,
-               void(const std::vector<uint8_t>&,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD3(RecordDarkResumeWakeReason,
-               bool(const std::vector<uint8_t>&,
-                    brillo::ErrorPtr*,
-                    int));
-  MOCK_METHOD4(RecordDarkResumeWakeReasonAsync,
-               void(const std::vector<uint8_t>&,
-                    const base::Callback<void()>&,
-                    const base::Callback<void(brillo::Error*)>&,
-                    int));
-  MOCK_METHOD2(RegisterBrightnessChangedSignalHandler,
-               void(const base::Callback<void(int32_t,
-                                              bool)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterKeyboardBrightnessChangedSignalHandler,
-               void(const base::Callback<void(int32_t,
-                                              bool)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterPeripheralBatteryStatusSignalHandler,
-               void(const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterPowerSupplyPollSignalHandler,
-               void(const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterSuspendImminentSignalHandler,
-               void(const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterSuspendDoneSignalHandler,
-               void(const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterDarkSuspendImminentSignalHandler,
-               void(const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterInputEventSignalHandler,
-               void(const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterIdleActionImminentSignalHandler,
-               void(const base::Callback<void(const std::vector<uint8_t>&)>&,
-                    dbus::ObjectProxy::OnConnectedCallback));
-  MOCK_METHOD2(RegisterIdleActionDeferredSignalHandler,
-               void(const base::Closure&,
-                    dbus::ObjectProxy::OnConnectedCallback));
- private:
-  dbus::ObjectProxy* object_proxy_;
-};
-
-}  // namespace trunks
-
-#endif  // TRUNKS_MOCK_POWER_MANAGER_PROXY_H_
diff --git a/trunks/power_manager.h b/trunks/power_manager.h
index 0176b27..347e8fd 100644
--- a/trunks/power_manager.h
+++ b/trunks/power_manager.h
@@ -21,7 +21,7 @@
 #include <string>
 
 #include <base/memory/weak_ptr.h>
-#include <power_manager-client/power_manager/dbus-proxies.h>
+#include <power_manager/dbus-proxies.h>
 
 #include "trunks/resource_manager.h"
 
diff --git a/trunks/power_manager_test.cc b/trunks/power_manager_test.cc
index 6ff107e..bbe530b 100644
--- a/trunks/power_manager_test.cc
+++ b/trunks/power_manager_test.cc
@@ -21,11 +21,11 @@
 #include <gmock/gmock.h>
 #include <google/protobuf/message_lite.h>
 #include <gtest/gtest.h>
+#include <power_manager/dbus-proxy-mocks.h>
 #include <power_manager/proto_bindings/suspend.pb.h>
 
 #include "trunks/mock_command_transceiver.h"
 #include "trunks/mock_dbus_object_proxy.h"
-#include "trunks/mock_power_manager_proxy.h"
 #include "trunks/mock_resource_manager.h"
 #include "trunks/trunks_factory_for_test.h"
 
@@ -127,6 +127,8 @@
             }));
     ON_CALL(proxy_, UnregisterSuspendDelay(_, _, _))
         .WillByDefault(Return(true));
+    ON_CALL(proxy_, GetObjectProxy())
+        .WillByDefault(Return(object_proxy_.get()));
   }
 
   void SendSuspendDone(int32_t suspend_id = kSomeSuspendId) {
@@ -277,7 +279,7 @@
   using MockDBusObjectProxyType = StrictMock<MockDBusObjectProxy>;
   scoped_refptr<MockDBusObjectProxyType> object_proxy_ =
       new MockDBusObjectProxyType();
-  StrictMock<MockPowerManagerProxy> proxy_{object_proxy_.get()};
+  org::chromium::PowerManagerProxyMock proxy_;
   TrunksFactoryForTest factory_;
   StrictMock<MockCommandTransceiver> transceiver_;
   StrictMock<MockResourceManager> resource_manager_{factory_, &transceiver_};
diff --git a/trunks/trunks.gyp b/trunks/trunks.gyp
index bd4d028..71901d2 100644
--- a/trunks/trunks.gyp
+++ b/trunks/trunks.gyp
@@ -131,6 +131,11 @@
     {
       'target_name': 'trunksd_lib',
       'type': 'static_library',
+      'variables': {
+        'deps': [
+          'libpower_manager-client',
+        ],
+      },
       'sources': [
         'power_manager.cc',
         'resource_manager.cc',
@@ -145,6 +150,11 @@
         'libraries': [
           '-lsystem_api-power_manager-protos',
         ],
+        'variables': {
+          'deps': [
+            'libpower_manager-client',
+          ],
+        },
       },
     },
     {
@@ -186,6 +196,11 @@
           'target_name': 'trunks_testrunner',
           'type': 'executable',
           'includes': ['../../../../platform2/common-mk/common_test.gypi'],
+          'variables': {
+            'deps': [
+              'libpower_manager-client-test',
+            ],
+          },
           'sources': [
             'background_command_transceiver_test.cc',
             'scoped_global_session_test.cc',