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

chrome/browser/media/router/media_router_mojo_impl_unittest.cc

 // 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.
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/histogram_tester.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_router_metrics.h"
 #include "chrome/browser/media/router/media_router_mojo_test.h"
 #include "chrome/browser/media/router/media_router_type_converters.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/version_info/version_info.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_factory.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_builder.h"
+#include "extensions/common/test_util.h"
+#include "extensions/common/value_builder.h"
 #include "media/base/gmock_callback_support.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Eq;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::IsEmpty;
 using testing::Mock;
 using testing::Not;
 using testing::Pointee;
 using testing::Return;
 using testing::ReturnRef;
 using testing::SaveArg;
 
 namespace media_router {
 
 using PresentationConnectionState =
     interfaces::MediaRouter::PresentationConnectionState;
 using PresentationConnectionCloseReason =
     interfaces::MediaRouter::PresentationConnectionCloseReason;
 
 namespace {
 
 const char kDescription[] = "description";
 const char kError[] = "error";
-const char kExtensionId[] = "extension1234";
 const char kMessage[] = "message";
 const char kSource[] = "source1";
 const char kSource2[] = "source2";
 const char kRouteId[] = "routeId";
 const char kRouteId2[] = "routeId2";
 const char kJoinableRouteId[] = "joinableRouteId";
 const char kJoinableRouteId2[] = "joinableRouteId2";
 const char kSinkId[] = "sink";
 const char kSinkId2[] = "sink2";
 const char kSinkName[] = "sinkName";
@@ skipping 967 matching lines @@
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)));
   ConnectProviderManagerService();
   ProcessEventLoop();
 }
 
 class MediaRouterMojoExtensionTest : public ::testing::Test {
  public:
   MediaRouterMojoExtensionTest()
-    : process_manager_(nullptr),
-      message_loop_(mojo::common::MessagePumpMojo::Create())
-  {}
+      : process_manager_(nullptr),
+        message_loop_(mojo::common::MessagePumpMojo::Create()) {}
 
   ~MediaRouterMojoExtensionTest() override {}
 
  protected:
   void SetUp() override {
+    // Set the extension's version number to be identical to the browser's.
+    extension_ =
+        extensions::test_util::BuildExtension(extensions::ExtensionBuilder())
+            .MergeManifest(extensions::DictionaryBuilder()
+                               .Set("version", version_info::GetVersionNumber())
+                               .Build())
+            .Build();
+
     profile_.reset(new TestingProfile);
     // Set up a mock ProcessManager instance.
     extensions::ProcessManagerFactory::GetInstance()->SetTestingFactory(
         profile_.get(), &TestProcessManager::Create);
     process_manager_ = static_cast<TestProcessManager*>(
         extensions::ProcessManager::Get(profile_.get()));
     DCHECK(process_manager_);
 
     // Create MR and its proxy, so that it can be accessed through Mojo.
     media_router_.reset(new MediaRouterMojoImpl(process_manager_));
     ProcessEventLoop();
   }
 
   void TearDown() override {
     media_router_.reset();
     profile_.reset();
     // Explicitly delete the TestingBrowserProcess before |message_loop_|.
     // This allows it to do cleanup before |message_loop_| goes away.
     TestingBrowserProcess::DeleteInstance();
   }
 
   // Constructs bindings so that |media_router_| delegates calls to
   // |mojo_media_router_|, which are then handled by
   // |mock_media_route_provider_service_|.
   void BindMediaRouteProvider() {
     binding_.reset(new mojo::Binding<interfaces::MediaRouteProvider>(
         &mock_media_route_provider_,
         mojo::GetProxy(&media_route_provider_proxy_)));
     media_router_->BindToMojoRequest(mojo::GetProxy(&media_router_proxy_),
-                                     kExtensionId);
+                                     *extension_);
   }
 
   void ResetMediaRouteProvider() {
     binding_.reset();
     media_router_->BindToMojoRequest(mojo::GetProxy(&media_router_proxy_),
-                                     kExtensionId);
+                                     *extension_);
   }
 
   void RegisterMediaRouteProvider() {
     media_router_proxy_->RegisterMediaRouteProvider(
         std::move(media_route_provider_proxy_),
         base::Bind(&RegisterMediaRouteProviderHandler::Invoke,
                    base::Unretained(&provide_handler_)));
   }
 
   void ProcessEventLoop() {
     message_loop_.RunUntilIdle();
   }
 
   void ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason reason,
                                    int expected_count) {
     histogram_tester_.ExpectBucketCount("MediaRouter.Provider.WakeReason",
                                         static_cast<int>(reason),
                                         expected_count);
   }
 
+  void ExpectVersionBucketCount(MediaRouteProviderVersion version,
+                                int expected_count) {
+    histogram_tester_.ExpectBucketCount("MediaRouter.Provider.Version",
+                                        static_cast<int>(version),
+                                        expected_count);
+  }
+
+  void ExpectWakeupBucketCount(MediaRouteProviderWakeup wakeup,
+                               int expected_count) {
+    histogram_tester_.ExpectBucketCount("MediaRouter.Provider.Wakeup",
+                                        static_cast<int>(wakeup),
+                                        expected_count);
+  }
+
   scoped_ptr<MediaRouterMojoImpl> media_router_;
   RegisterMediaRouteProviderHandler provide_handler_;
   TestProcessManager* process_manager_;
   testing::StrictMock<MockMediaRouteProvider> mock_media_route_provider_;
   interfaces::MediaRouterPtr media_router_proxy_;
+  scoped_refptr<extensions::Extension> extension_;
 
  private:
   scoped_ptr<TestingProfile> profile_;
   base::MessageLoop message_loop_;
   interfaces::MediaRouteProviderPtr media_route_provider_proxy_;
   scoped_ptr<mojo::Binding<interfaces::MediaRouteProvider>> binding_;
   base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoExtensionTest);
 };
 
 TEST_F(MediaRouterMojoExtensionTest, DeferredBindingAndSuspension) {
   // DetachRoute is called before *any* extension has connected.
   // It should be queued.
   media_router_->DetachRoute(kRouteId);
 
   BindMediaRouteProvider();
 
   base::RunLoop run_loop, run_loop2;
   // |mojo_media_router| signals its readiness to the MR by registering
   // itself via RegisterMediaRouteProvider().
   // Now that the |media_router| and |mojo_media_router| are fully initialized,
   // the queued DetachRoute() call should be executed.
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
       .WillOnce(InvokeWithoutArgs([&run_loop]() {
                   run_loop.Quit();
                 }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId)))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
                   run_loop2.Quit();
                 }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
 
   base::RunLoop run_loop3;
   // Extension is suspended and re-awoken.
   ResetMediaRouteProvider();
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
-      .WillOnce(testing::DoAll(media::RunCallback<1>(true),
-                               InvokeWithoutArgs([&run_loop3]() {
-                                 run_loop3.Quit();
-                               }),
-                               Return(true)));
+  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
+      .WillOnce(testing::DoAll(
+          media::RunCallback<1>(true),
+          InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); }),
+          Return(true)));
   media_router_->DetachRoute(kRouteId2);
   run_loop3.Run();
 
   base::RunLoop run_loop4, run_loop5;
   // RegisterMediaRouteProvider() is called.
   // The queued DetachRoute(kRouteId2) call should be executed.
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
       .WillOnce(InvokeWithoutArgs([&run_loop4]() {
                   run_loop4.Quit();
                 }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)))
       .WillOnce(InvokeWithoutArgs([&run_loop5]() {
                   run_loop5.Quit();
                 }));
   BindMediaRouteProvider();
   RegisterMediaRouteProvider();
   run_loop4.Run();
   run_loop5.Run();
   ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
+  ExpectWakeupBucketCount(MediaRouteProviderWakeup::SUCCESS, 1);
+  ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
+                           1);
 }
 
 TEST_F(MediaRouterMojoExtensionTest, AttemptedWakeupTooManyTimes) {
   BindMediaRouteProvider();
 
   // DetachRoute is called while extension is suspended. It should be queued.
   // Schedule a component extension wakeup.
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
+  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
       .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
   media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
   ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
+  ExpectWakeupBucketCount(MediaRouteProviderWakeup::SUCCESS, 1);
 
   // Media route provider fails to connect to media router before extension is
   // suspended again, and |OnConnectionError| is invoked. Retry the wakeup.
-  EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
+  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
       .Times(MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1)
       .WillRepeatedly(
           testing::DoAll(media::RunCallback<1>(true), Return(true)));
   for (int i = 0; i < MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1; ++i)
     media_router_->OnConnectionError();
 
   // We have already tried |kMaxWakeupAttemptCount| times. If we get an error
   // again, we will give up and the pending request queue will be drained.
   media_router_->OnConnectionError();
   EXPECT_TRUE(media_router_->pending_requests_.empty());
   ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::CONNECTION_ERROR,
                               MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1);
+  ExpectWakeupBucketCount(MediaRouteProviderWakeup::ERROR_TOO_MANY_RETRIES, 1);
 
   // Requests that comes in after queue is drained should be queued.
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
+  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
       .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
   media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
+  ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
+                           1);
 }
 
 TEST_F(MediaRouterMojoExtensionTest, WakeupFailedDrainsQueue) {
   BindMediaRouteProvider();
 
   // DetachRoute is called while extension is suspended. It should be queued.
   // Schedule a component extension wakeup.
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(true));
   base::Callback<void(bool)> extension_wakeup_callback;
-  EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
+  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
       .WillOnce(
           testing::DoAll(SaveArg<1>(&extension_wakeup_callback), Return(true)));
   media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
 
   // Extension wakeup callback returning false is an non-retryable error.
   // Queue should be drained.
   extension_wakeup_callback.Run(false);
   EXPECT_TRUE(media_router_->pending_requests_.empty());
 
   // Requests that comes in after queue is drained should be queued.
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
       .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(kExtensionId, _))
+  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
       .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
   media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
   ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
+  ExpectWakeupBucketCount(MediaRouteProviderWakeup::ERROR_UNKNOWN, 1);
+  ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
+                           1);
 }
 
 TEST_F(MediaRouterMojoExtensionTest, DropOldestPendingRequest) {
   const size_t kMaxPendingRequests = MediaRouterMojoImpl::kMaxPendingRequests;
 
   // Request is queued.
   media_router_->DetachRoute(kRouteId);
   EXPECT_EQ(1u, media_router_->pending_requests_.size());
 
   for (size_t i = 0; i < kMaxPendingRequests; ++i)
     media_router_->DetachRoute(kRouteId2);
 
   // The request queue size should not exceed |kMaxPendingRequests|.
   EXPECT_EQ(kMaxPendingRequests, media_router_->pending_requests_.size());
 
   base::RunLoop run_loop, run_loop2;
   size_t count = 0;
   // The oldest request should have been dropped, so we don't expect to see
   // DetachRoute(kRouteId) here.
   BindMediaRouteProvider();
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")))
       .WillOnce(InvokeWithoutArgs([&run_loop]() {
                   run_loop.Quit();
                 }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId));
+  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)))
       .Times(kMaxPendingRequests)
       .WillRepeatedly(InvokeWithoutArgs([&run_loop2, &count]() {
                         if (++count == MediaRouterMojoImpl::kMaxPendingRequests)
                           run_loop2.Quit();
                       }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
+  ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
+                           1);
 }
 
 }  // namespace media_router