chromeos: Make CrosDBusService not be a singleton.

chromeos/dbus/services/cros_dbus_service_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/dbus/services/cros_dbus_service.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_exported_object.h"
 #include "dbus/mock_object_proxy.h"
 #include "dbus/object_path.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
+using ::testing::_;
 using ::testing::Eq;
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace chromeos {
 
 class MockProxyResolutionService
     : public CrosDBusService::ServiceProviderInterface {
  public:
   MOCK_METHOD1(Start, void(scoped_refptr<dbus::ExportedObject>
                            exported_object));
 };

[satorux1, 2017/02/15 06:48:01]

while you are at it, i'd appreciate it if you could get rid of the gmock class.
:) well, we'll still have to live with MockBus etc., but one less gmock class
would be nice.

[Daniel Erat, 2017/02/15 16:57:00]

i actually don't mind this particular usage of gmock, because it's small,
simple, and self-contained, and only verifies what is actually being tested
(i.e. that Start is called exactly once with the expected exported object).

if i change this to instead be a handwritten stub class, i'll need to make it
save the exported object that's passed to it, and then make the test class also
save the exported object that it creates, and then compare them in the test
body, right?

i'm happy to change this in a followup change if you can explain more.

 
 class CrosDBusServiceTest : public testing::Test {
  public:
-  CrosDBusServiceTest() {
-  }
+  CrosDBusServiceTest() = default;
 
   // Creates an instance of CrosDBusService with mocks injected.
   void SetUp() override {
     // Create a mock bus.
     dbus::Bus::Options options;
     options.bus_type = dbus::Bus::SYSTEM;
     mock_bus_ = new dbus::MockBus(options);
 
     // ShutdownAndBlock() will be called in TearDown().
     EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
 
-    // Create a mock exported object that behaves as
-    // org.chromium.CrosDBusService.
+    // CrosDBusService should take ownership of the service name passed to it.
+    const char kServiceName[] = "org.example.TestService";
+    EXPECT_CALL(
+        *mock_bus_.get(),
+        RequestOwnership(kServiceName,
+                         dbus::Bus::REQUIRE_PRIMARY_ALLOW_REPLACEMENT, _))
+        .Times(1);
+
+    // Create a mock exported object.
+    const dbus::ObjectPath kObjectPath("/org/example/TestService");
     mock_exported_object_ =
-        new dbus::MockExportedObject(mock_bus_.get(),
-                                     dbus::ObjectPath(kLibCrosServicePath));
+        new dbus::MockExportedObject(mock_bus_.get(), kObjectPath);
 
     // |mock_bus_|'s GetExportedObject() will return mock_exported_object_|
     // for the given service name and the object path.
-    EXPECT_CALL(*mock_bus_.get(),
-                GetExportedObject(dbus::ObjectPath(kLibCrosServicePath)))
+    EXPECT_CALL(*mock_bus_.get(), GetExportedObject(kObjectPath))
         .WillOnce(Return(mock_exported_object_.get()));
 
     // Create a mock proxy resolution service.
     auto mock_proxy_resolution_service_provider =
         base::MakeUnique<MockProxyResolutionService>();
 
     // Start() will be called with |mock_exported_object_|.
     EXPECT_CALL(*mock_proxy_resolution_service_provider,
                 Start(Eq(mock_exported_object_))).WillOnce(Return());
+
     // Initialize the cros service with the mocks injected.
     CrosDBusService::ServiceProviderList service_providers;
     service_providers.push_back(
         std::move(mock_proxy_resolution_service_provider));
-    CrosDBusService::InitializeForTesting(mock_bus_.get(),
-                                          std::move(service_providers));
+    cros_dbus_service_ = CrosDBusService::CreateRealImpl(
+        mock_bus_.get(), kServiceName, kObjectPath,
+        std::move(service_providers));
   }
 
   void TearDown() override {
-    // Shutdown the cros service.
-    CrosDBusService::Shutdown();
-
-    // Shutdown the bus.
+    cros_dbus_service_.reset();
     mock_bus_->ShutdownAndBlock();
   }
 
  protected:
   scoped_refptr<dbus::MockBus> mock_bus_;
   scoped_refptr<dbus::MockExportedObject> mock_exported_object_;
+  std::unique_ptr<CrosDBusService> cros_dbus_service_;
 };
 
 TEST_F(CrosDBusServiceTest, Start) {
   // Simply start the service and see if mock expectations are met:
   // - The service object is exported by GetExportedObject()
   // - The proxy resolution service is started.
 }
 
 }  // namespace chromeos