[Device Discovery] Make DialRegistry a Singleton

chrome/browser/media/router/discovery/dial/dial_registry_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 <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/media/router/discovery/dial/dial_device_data.h"
 #include "chrome/browser/media/router/discovery/dial/dial_registry.h"
 #include "chrome/browser/media/router/discovery/dial/dial_service.h"
@@ skipping 32 matching lines @@
 };
 
 class MockDialRegistry : public DialRegistry {
  public:
   MockDialRegistry(const base::TimeDelta& refresh_interval,
                    const base::TimeDelta& expiration,
                    const size_t max_devices)
       : DialRegistry(refresh_interval, expiration, max_devices),
         time_(Time::Now()) {}
 
+  // Returns the mock Dial service.
+  MockDialService& mock_service() { return mock_service_; }
+
+  void set_time(Time time) { time_ = time; }
+
+ protected:
   ~MockDialRegistry() override {
     // Don't let the DialRegistry delete this.
     DialService* tmp = dial_.release();
     if (tmp)
       CHECK_EQ(&mock_service_, tmp);
   }
 
-  // Returns the mock Dial service.
-  MockDialService& mock_service() { return mock_service_; }
-
-  void set_time(Time time) { time_ = time; }
-
- protected:
   base::Time Now() const override { return time_; }
 
   std::unique_ptr<DialService> CreateDialService() override {
     return base::WrapUnique(&mock_service_);
   }
 
   void ClearDialService() override {
     // Release the pointer but don't delete the object because the test owns it.
     CHECK_EQ(&mock_service_, dial_.release());
   }
 
  private:
   MockDialService mock_service_;
 
   // Set to mock out the current time.
   Time time_;
 };
 
 class DialRegistryTest : public testing::Test {
  public:
   DialRegistryTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         first_device_("first", GURL("http://127.0.0.1/dd.xml"), Time::Now()),
         second_device_("second", GURL("http://127.0.0.2/dd.xml"), Time::Now()),
         third_device_("third", GURL("http://127.0.0.3/dd.xml"), Time::Now()) {
-    registry_ = base::MakeUnique<MockDialRegistry>(
-        TimeDelta::FromSeconds(1000), TimeDelta::FromSeconds(10), 10);
+    registry_ = scoped_refptr<MockDialRegistry>(new MockDialRegistry(
+        TimeDelta::FromSeconds(1000), TimeDelta::FromSeconds(10), 10));
     registry_->RegisterObserver(&mock_observer_);
     list_with_first_device_.push_back(first_device_);
     list_with_second_device_.push_back(second_device_);
   }
 
  protected:
   void SetListenerExpectations() {
     EXPECT_CALL(registry_->mock_service(),
                 AddObserver(A<DialService::Observer*>()));
     EXPECT_CALL(registry_->mock_service(),
                 RemoveObserver(A<DialService::Observer*>()));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  std::unique_ptr<MockDialRegistry> registry_;
+  scoped_refptr<MockDialRegistry> registry_;
   MockDialObserver mock_observer_;
   const DialDeviceData first_device_;
   const DialDeviceData second_device_;
   const DialDeviceData third_device_;
 
   const DialRegistry::DeviceList empty_list_;
   DialRegistry::DeviceList list_with_first_device_;
   DialRegistry::DeviceList list_with_second_device_;
 };
 
@@ skipping 248 matching lines @@
   registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, third_device_);
   registry_->OnDiscoveryFinished(nullptr);
 
   registry_->OnListenerRemoved();
 }
 
 }  // namespace media_router