[Media Router] Use DialMediaSinkService in MediaRouterMojoImpl

chrome/browser/media/router/discovery/dial/dial_media_sink_service.h

 // Copyright 2017 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.
 
 #ifndef CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_DIAL_MEDIA_SINK_SERVICE_H_
 #define CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_DIAL_MEDIA_SINK_SERVICE_H_
 
 #include <memory>
 #include <set>
 
+#include "base/memory/ref_counted.h"
 #include "chrome/browser/media/router/discovery/dial/device_description_service.h"
 #include "chrome/browser/media/router/discovery/dial/dial_registry.h"
 #include "chrome/common/media_router/discovery/media_sink_internal.h"
 #include "chrome/common/media_router/discovery/media_sink_service.h"
+#include "content/public/browser/browser_thread.h"
 
 namespace media_router {
 
 class DeviceDescriptionService;
 class DialRegistry;
 
 // A service which can be used to start background discovery and resolution of
 // DIAL devices (Smart TVs, Game Consoles, etc.).
-// This class is not thread safe. All methods must be called from the IO thread.
+// This class is thread safe.

[mark a. foltz, 2017/05/09 18:21:13]

Yes, but the public API (including the OnSinksDiscoveredCallback) must be called
on the UI thread because of the DCHECKs().  It would be important to mention
that.

[zhaobin, 2017/05/10 18:17:34]

Done.

 class DialMediaSinkService : public MediaSinkService,
-                             public DialRegistry::Observer {
+                             public DialRegistry::Observer,
+                             public base::RefCountedThreadSafe<
+                                 DialMediaSinkService,
+                                 content::BrowserThread::DeleteOnIOThread> {
  public:
   DialMediaSinkService(const OnSinksDiscoveredCallback& callback,
                        net::URLRequestContextGetter* request_context);
-  ~DialMediaSinkService() override;
+
+  // Stop listening to DIAL device events.
+  void Stop();
 
   // MediaSinkService implementation
   void Start() override;
 
-  void Stop();
-
  protected:
-  virtual DialRegistry* dial_registry();
+  ~DialMediaSinkService() override;
 
   // Returns instance of device description service. Create a new one if none
   // exists.
-  virtual DeviceDescriptionService* GetDescriptionService();
+  DeviceDescriptionService* GetDescriptionService();
+
+  // Does not take ownership of |dial_registry|.
+  void SetDialRegistryForTest(DialRegistry* dial_registry);
+  void SetDescriptionServiceForTest(
+      std::unique_ptr<DeviceDescriptionService> description_service);
+  void SetTimerForTest(std::unique_ptr<base::Timer> timer);
 
  private:
+  friend struct content::BrowserThread::DeleteOnThread<
+      content::BrowserThread::IO>;
+  friend class base::DeleteHelper<DialMediaSinkService>;
   friend class DialMediaSinkServiceTest;
   FRIEND_TEST_ALL_PREFIXES(DialMediaSinkServiceTest, TestStart);
-  FRIEND_TEST_ALL_PREFIXES(DialMediaSinkServiceTest, TestFetchCompleted);
+  FRIEND_TEST_ALL_PREFIXES(DialMediaSinkServiceTest, TestTimer);
+  FRIEND_TEST_ALL_PREFIXES(DialMediaSinkServiceTest,
+                           TestFetchCompleted_SameSink);
   FRIEND_TEST_ALL_PREFIXES(DialMediaSinkServiceTest, TestIsDifferent);
   FRIEND_TEST_ALL_PREFIXES(DialMediaSinkServiceTest,
                            TestOnDeviceDescriptionAvailable);
 
+  // Start discovery on IO thread.
+  void StartOnIOThread();
+
+  // Stop discovery on IO thread.
+  void StopOnIOThread();
+
+  // Called when |finish_timer_| expires.
+  void OnFetchCompletedOnUIThread();
+
   // api::dial::DialRegistry::Observer implementation
   void OnDialDeviceEvent(const DialRegistry::DeviceList& devices) override;
   void OnDialError(DialRegistry::DialErrorCode type) override;
 
   // Called when description service successfully fetches and parses device
   // description XML. Restart |finish_timer_| if it is not running.
   void OnDeviceDescriptionAvailable(
       const DialDeviceData& device_data,
       const ParsedDialDeviceDescription& description_data);
 
   // Called when fails to fetch or parse device description XML.
   void OnDeviceDescriptionError(const DialDeviceData& device,
                                 const std::string& error_message);
 
-  // Called when |finish_timer_| expires.
+  // Called when |finish_timer_| expires and post task on UI thread.
   void OnFetchCompleted();
 
   // Timer for finishing fetching. Starts in |OnDialDeviceEvent()|, and expires
   // 3 seconds later. If |OnDeviceDescriptionAvailable()| is called after
   // |finish_timer_| expires, |finish_timer_| is restarted.
-  std::unique_ptr<base::OneShotTimer> finish_timer_;
+  std::unique_ptr<base::Timer> finish_timer_;
 
   std::unique_ptr<DeviceDescriptionService> description_service_;

[mark a. foltz, 2017/05/09 18:21:13]

I didn't see where this was set; is this only set for tests?  If so, name it
test_description_service_ to be specific.

[zhaobin, 2017/05/10 18:17:34]

It is set in DialMediaSinkService::GetDescriptionService()

 
+  // Raw pointer to DialRegistry singleton.
+  DialRegistry* dial_registry_ = nullptr;

[mark a. foltz, 2017/05/09 18:21:13]

What guarantees that the DialRegistry will outlive this object?

[zhaobin, 2017/05/10 18:17:34]

DialRegistry is a Leaky Singleton...

https://cs.chromium.org/chromium/src/chrome/browser/media/router/discovery/di...

+
   // Sorted sinks from current round of discovery.
   std::set<MediaSinkInternal> current_sinks_;
 
   // Sorted sinks sent to Media Router Provider in last FetchCompleted().
   std::set<MediaSinkInternal> mrp_sinks_;
 
   // Device data list from current round of discovery.
   DialRegistry::DeviceList current_devices_;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_DIAL_MEDIA_SINK_SERVICE_H_