Shows a launch spinner next to a sink once it is selected to create a route. The launch spinner sur…

chrome/browser/media/router/media_router_mojo_impl.h

 // Copyright 2015 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_MEDIA_ROUTER_MOJO_IMPL_H_
 #define CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_
 
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
@@ skipping 70 matching lines @@
   void UnregisterIssuesObserver(IssuesObserver* observer) override;
 
   const std::string& media_route_provider_extension_id() const {
     return media_route_provider_extension_id_;
   }
 
   void set_instance_id_for_test(const std::string& instance_id) {
     instance_id_ = instance_id;
   }
 
+  const std::set<MediaSink::Id>& sink_ids_in_launch() const {

[Kevin M, 2015/08/08 00:35:56]

ISTM that this doesn't belong at this layer - there is very little information
about sinks and routes that is persisted in this object, and I think we should
try to maintain that separation.

Can you move this to media_router_ui?

[haibinlu, 2015/08/08 01:25:38]

It cannot. It has to survive UI close and reopen. Plus, auto-mirroring-to-flings
transition (yet to be implemented) will go without UI open; mirroring launch
state needs to be kept outside UI too.

+    return sink_ids_in_launch_;
+  }
+
  private:
   friend class MediaRouterFactory;
   friend class MediaRouterMojoTest;
 
   FRIEND_TEST_ALL_PREFIXES(MediaRouterMojoExtensionTest,
                            DeferredBindingAndSuspension);
 
   // Standard constructor, used by
   // MediaRouterMojoImplFactory::GetApiForBrowserContext.
   explicit MediaRouterMojoImpl(
@@ skipping 56 matching lines @@
   // interfaces::MediaRouter implementation.
   void RegisterMediaRouteProvider(
       interfaces::MediaRouteProviderPtr media_route_provider_ptr,
       const interfaces::MediaRouter::RegisterMediaRouteProviderCallback&
           callback) override;
   void OnIssue(interfaces::IssuePtr issue) override;
   void OnSinksReceived(const mojo::String& media_source,
                        mojo::Array<interfaces::MediaSinkPtr> sinks) override;
   void OnRoutesUpdated(mojo::Array<interfaces::MediaRoutePtr> routes) override;
 
+  void RouteResponseReceived(
+      const std::vector<MediaRouteResponseCallback>& callbacks,
+      const MediaSink::Id& sink_id,
+      interfaces::MediaRoutePtr media_route,
+      const mojo::String& error_text);
+
   // Pending requests queued to be executed once component extension
   // becomes ready.
   std::vector<base::Closure> pending_requests_;
 
   base::ScopedPtrHashMap<MediaSource::Id,
                          scoped_ptr<base::ObserverList<MediaSinksObserver>>>
       sinks_observers_;
 
   base::ObserverList<MediaRoutesObserver> routes_observers_;
 
   IssueManager issue_manager_;
 
   // Binds |this| to a Mojo connection stub for interfaces::MediaRouter.
   scoped_ptr<mojo::Binding<interfaces::MediaRouter>> binding_;
 
   // Mojo proxy object for the Media Route Provider Manager.
   // Set to null initially, and later set to the Provider Manager proxy object
   // passed in via |RegisterMediaRouteProvider()|.
   // This is set to null again when the component extension is suspended
   // if or a Mojo channel error occured.
   interfaces::MediaRouteProviderPtr media_route_provider_;
 
   // Id of the component extension. Used for managing its suspend/wake state
   // via event_page_tracker_.
   std::string media_route_provider_extension_id_;
 
+  // The Ids of the sinks to which media router are creating routes.
+  std::set<MediaSink::Id> sink_ids_in_launch_;
+
   // Allows the extension to be monitored for suspend, and woken.
   // This is a reference to a BrowserContext keyed service that outlives this
   // instance.
   extensions::EventPageTracker* event_page_tracker_;
 
   // GUID unique to each browser run. Component extension uses this to detect
   // when its persisted state was written by an older browser instance, and is
   // therefore stale.
   std::string instance_id_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoImpl);
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_