Worker: Enable UseCounter for SharedWorkerGlobalScope

content/browser/shared_worker/shared_worker_service_impl_unittest.cc

Index: content/browser/shared_worker/shared_worker_service_impl_unittest.cc
diff --git a/content/browser/shared_worker/shared_worker_service_impl_unittest.cc b/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
index b1b809a54586840c2f2eb20559218aa82df18558..34612e9172dd303d2c3addcab2d0c26e48f24ab8 100644
--- a/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
+++ b/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
@@ -351,6 +351,18 @@ void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host,
   EXPECT_EQ(connector->route_id(), msg->routing_id());
 }
 
+void CheckViewMsgCountFeature(MockRendererProcessHost* renderer_host,
+                              MockSharedWorkerConnector* connector,
+                              uint32_t expected_use_counter_id) {
+  std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
+  EXPECT_EQ(ViewMsg_CountFeatureOnSharedWorker::ID, msg->type());
+  EXPECT_EQ(connector->route_id(), msg->routing_id());
+  ViewMsg_CountFeatureOnSharedWorker::Param params;
+  EXPECT_TRUE(ViewMsg_CountFeatureOnSharedWorker::Read(msg.get(), &params));
+  uint32_t use_counter_id = std::get<0>(params);
+  EXPECT_EQ(expected_use_counter_id, use_counter_id);
+}
+
 void CheckMessagePortMsgMessagesQueued(MockRendererProcessHost* renderer_host,
                                        MockSharedWorkerConnector* connector) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
@@ -385,10 +397,15 @@ void CheckMessagePortMsgMessage(MockRendererProcessHost* renderer_host,
 }
 
 void CheckViewMsgWorkerConnected(MockRendererProcessHost* renderer_host,
-                                 MockSharedWorkerConnector* connector) {
+                                 MockSharedWorkerConnector* connector,
+                                 std::set<uint32_t> expected_use_counter) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(ViewMsg_WorkerConnected::ID, msg->type());
   EXPECT_EQ(connector->route_id(), msg->routing_id());
+  ViewMsg_WorkerConnected::Param params;
+  EXPECT_TRUE(ViewMsg_WorkerConnected::Read(msg.get(), &params));
+  std::set<uint32_t> use_counter = std::get<0>(params);
+  EXPECT_EQ(expected_use_counter, use_counter);
 }
 
 }  // namespace
@@ -465,7 +482,8 @@ TEST_F(SharedWorkerServiceImplTest, BasicTest) {
           connector->remote_port_id(), worker_route_id)));
   EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
   // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side.
-  CheckViewMsgWorkerConnected(renderer_host.get(), connector.get());
+  CheckViewMsgWorkerConnected(renderer_host.get(), connector.get(),
+                              std::set<uint32_t>());
 
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
@@ -485,6 +503,30 @@ TEST_F(SharedWorkerServiceImplTest, BasicTest) {
   CheckMessagePortMsgMessage(
       renderer_host.get(), connector->local_port_route_id(), "test2");
 
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature().
+  uint32_t use_counter_id1 = 124;
+  EXPECT_TRUE(renderer_host->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, use_counter_id1)));
+  EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
+  // ViewMsg_CountFeature should be sent to SharedWorkerConnector side.
+  CheckViewMsgCountFeature(renderer_host.get(), connector.get(),
+                           use_counter_id1);
+  // A message should be sent only one time per use_counter_id.
+  EXPECT_TRUE(renderer_host->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, use_counter_id1)));
+  EXPECT_EQ(0U, renderer_host->QueuedMessageCount());
+
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature() for another use_counter_id use.
+  uint32_t use_counter_id2 = 901;
+  EXPECT_TRUE(renderer_host->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, use_counter_id2)));
+  EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
+  // ViewMsg_CountFeature should be sent to SharedWorkerConnector side.
+  CheckViewMsgCountFeature(renderer_host.get(), connector.get(),
+                           use_counter_id2);
+
   // UpdateWorkerDependency should not be called.
   EXPECT_EQ(0, s_update_worker_dependency_call_count_);
 }
@@ -562,7 +604,8 @@ TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) {
           connector0->remote_port_id(), worker_route_id)));
   EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
   // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side.
-  CheckViewMsgWorkerConnected(renderer_host0.get(), connector0.get());
+  CheckViewMsgWorkerConnected(renderer_host0.get(), connector0.get(),
+                              std::set<uint32_t>());
 
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
@@ -582,6 +625,23 @@ TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) {
   CheckMessagePortMsgMessage(
       renderer_host0.get(), connector0->local_port_route_id(), "test2");
 
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature().
+  uint32_t use_counter_id1 = 124;
+  EXPECT_TRUE(renderer_host0->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, use_counter_id1)));
+  EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
+  // ViewMsg_CountFeature should be sent to SharedWorkerConnector side.
+  CheckViewMsgCountFeature(renderer_host0.get(), connector0.get(),
+                           use_counter_id1);
+  uint32_t use_counter_id2 = 901;
+  EXPECT_TRUE(renderer_host0->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, use_counter_id2)));
+  EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
+  // ViewMsg_CountFeature should be sent to SharedWorkerConnector side.
+  CheckViewMsgCountFeature(renderer_host0.get(), connector0.get(),
+                           use_counter_id2);
+
   // The second renderer host.
   std::unique_ptr<MockRendererProcessHost> renderer_host1(
       new MockRendererProcessHost(kProcessIDs[1],
@@ -642,7 +702,8 @@ TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) {
           connector1->remote_port_id(), worker_route_id)));
   EXPECT_EQ(1U, renderer_host1->QueuedMessageCount());
   // ViewMsg_WorkerConnected should be sent to SharedWorkerConnector side.
-  CheckViewMsgWorkerConnected(renderer_host1.get(), connector1.get());
+  CheckViewMsgWorkerConnected(renderer_host1.get(), connector1.get(),
+                              {use_counter_id1, use_counter_id2});
 
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
@@ -661,6 +722,29 @@ TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) {
   CheckMessagePortMsgMessage(
       renderer_host1.get(), connector1->local_port_route_id(), "test4");
 
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature(). These use_counter are already
+  // counted in the browser-side, so messages should not be sent to
+  // SharedWorkerConnectors.
+  EXPECT_TRUE(renderer_host0->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, use_counter_id1)));
+  EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
+  EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
+
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature() for another use_counter_id use.
+  uint32_t use_counter_id3 = 1019;
+  EXPECT_TRUE(renderer_host0->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, use_counter_id3)));
+  // ViewMsg_CountFeature should be sent to all SharedWorkerConnectors
+  // connecting to this worker.
+  EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
+  CheckViewMsgCountFeature(renderer_host0.get(), connector0.get(),
+                           use_counter_id3);
+  EXPECT_EQ(1U, renderer_host1->QueuedMessageCount());
+  CheckViewMsgCountFeature(renderer_host1.get(), connector1.get(),
+                           use_counter_id3);
+
   EXPECT_EQ(1, s_update_worker_dependency_call_count_);
   renderer_host1.reset();
   // UpdateWorkerDependency should be called.