[Media Router] Add UMA histograms tracking component extension version/wakeups

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 <stdint.h>
 
 #include <deque>
@@ skipping 16 matching lines @@
 #include "chrome/browser/media/router/media_router_base.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
 namespace content {
 class BrowserContext;
 }
 
 namespace extensions {
 class EventPageTracker;
+class Extension;
 }
 
 namespace media_router {
 
 enum class MediaRouteProviderWakeReason;
 
 // MediaRouter implementation that delegates calls to the component extension.
 // Also handles the suspension and wakeup of the component extension.
 class MediaRouterMojoImpl : public MediaRouterBase,
                             public interfaces::MediaRouter {
  public:
   ~MediaRouterMojoImpl() override;
 
   // Sets up the MediaRouterMojoImpl instance owned by |context| to handle
   // MediaRouterObserver requests from the component extension given by
-  // |extension_id|. Creates the MediaRouterMojoImpl instance if it does not
+  // |extension|. Creates the MediaRouterMojoImpl instance if it does not
   // exist.
   // Called by the Mojo module registry.
-  // |extension_id|: The ID of the component extension, used for querying
+  // |extension|: The component extension, used for querying
   //     suspension state.
   // |context|: The BrowserContext which owns the extension process.
   // |request|: The Mojo connection request used for binding.
   static void BindToRequest(
-      const std::string& extension_id,
+      const extensions::Extension* extension,
       content::BrowserContext* context,
       mojo::InterfaceRequest<interfaces::MediaRouter> request);
 
   // MediaRouter implementation.
   // Execution of the requests is delegated to the Do* methods, which can be
   // enqueued for later use if the extension is temporarily suspended.
   void CreateRoute(const MediaSource::Id& source_id,
                    const MediaSink::Id& sink_id,
                    const GURL& origin,
                    content::WebContents* web_contents,
@@ skipping 104 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(MediaRoutesQuery);
   };
 
   // Standard constructor, used by
   // MediaRouterMojoImplFactory::GetApiForBrowserContext.
   explicit MediaRouterMojoImpl(
       extensions::EventPageTracker* event_page_tracker);
 
   // Binds |this| to a Mojo interface request, so that clients can acquire a
   // handle to a MediaRouterMojoImpl instance via the Mojo service connector.
-  // Stores the |extension_id| of the component extension.
+  // Stores the ID of |extension| in |media_route_provider_extension_id_|.
   void BindToMojoRequest(
       mojo::InterfaceRequest<interfaces::MediaRouter> request,
-      const std::string& extension_id);
+      const extensions::Extension& extension);
 
   // Enqueues a closure for later execution by ExecutePendingRequests().
   void EnqueueTask(const base::Closure& closure);
 
   // Runs a closure if the extension monitored by |extension_monitor_| is
   // active, or defers it for later execution if the extension is suspended.
   void RunOrDefer(const base::Closure& request);
 
   // Dispatches the Mojo requests queued in |pending_requests_|.
   void ExecutePendingRequests();
@@ skipping 164 matching lines @@
   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_;
 
   // The last reported sink availability from the media route provider manager.
   interfaces::MediaRouter::SinkAvailability availability_;
 
-  int wakeup_attempt_count_;
+  int wakeup_attempt_count_ = 0;
 
   // Records the current reason the extension is being woken up.  Is set to
   // MediaRouteProviderWakeReason::TOTAL_COUNT if there is no pending reason.
   MediaRouteProviderWakeReason current_wake_reason_;
 
+  // A flag to ensure that we record the provider version once, during the
+  // initial event page wakeup attempt.
+  bool provider_version_was_recorded_ = false;
+
   base::WeakPtrFactory<MediaRouterMojoImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoImpl);
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_MEDIA_ROUTER_MOJO_IMPL_H_