Worker: Enable UseCounter for SharedWorkerGlobalScope

content/browser/shared_worker/shared_worker_service_impl_unittest.cc

 // Copyright 2014 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 "content/browser/shared_worker/shared_worker_service_impl.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <tuple>
 
 #include "base/atomic_sequence_num.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/shared_worker/shared_worker_message_filter.h"
 #include "content/browser/shared_worker/worker_storage_partition.h"
 #include "content/common/message_port_messages.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
+#include "content/common/worker_use_counter.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "ipc/ipc_sync_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 class SharedWorkerServiceImplTest : public testing::Test {
@@ skipping 307 matching lines @@
   *route_id = std::get<0>(param).route_id;
 }
 
 void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host,
                                MockSharedWorkerConnector* connector) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(ViewMsg_WorkerCreated::ID, msg->type());
   EXPECT_EQ(connector->route_id(), msg->routing_id());
 }
 
+void CheckViewMsgCountFeature(MockRendererProcessHost* renderer_host,
+                              MockSharedWorkerConnector* connector,
+                              uint32_t expected_feature) {
+  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 feature = std::get<0>(params);
+  EXPECT_EQ(expected_feature, feature);
+}
+
 void CheckMessagePortMsgMessagesQueued(MockRendererProcessHost* renderer_host,
                                        MockSharedWorkerConnector* connector) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(MessagePortMsg_MessagesQueued::ID, msg->type());
   EXPECT_EQ(connector->temporary_remote_port_route_id(), msg->routing_id());
 }
 
 void CheckWorkerMsgConnect(MockRendererProcessHost* renderer_host,
                            int expected_msg_route_id,
                            int expected_sent_message_port_id,
@@ skipping 14 matching lines @@
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(MessagePortMsg_Message::ID, msg->type());
   EXPECT_EQ(expected_msg_route_id, msg->routing_id());
   MessagePortMsg_Message::Param params;
   EXPECT_TRUE(MessagePortMsg_Message::Read(msg.get(), &params));
   base::string16 data = std::get<0>(params);
   EXPECT_EQ(base::ASCIIToUTF16(expected_data), data);
 }
 
 void CheckViewMsgWorkerConnected(MockRendererProcessHost* renderer_host,
-                                 MockSharedWorkerConnector* connector) {
+                                 MockSharedWorkerConnector* connector,
+                                 std::vector<uint32_t> expected_features) {
   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::vector<char> dumped = std::get<0>(params);
+  WorkerUseCounter counter(dumped);
+  for (uint32_t feature : expected_features)
+    EXPECT_TRUE(counter.IsCounted(feature));
 }
 
 }  // namespace
 
 TEST_F(SharedWorkerServiceImplTest, BasicTest) {
   std::unique_ptr<MockRendererProcessHost> renderer_host(
       new MockRendererProcessHost(kProcessIDs[0],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
   std::unique_ptr<MockSharedWorkerConnector> connector(
@@ skipping 56 matching lines @@
       new WorkerHostMsg_WorkerScriptLoaded(worker_route_id)));
   EXPECT_EQ(0U, renderer_host->QueuedMessageCount());
 
   // SharedWorker sends WorkerHostMsg_WorkerConnected in
   // EmbeddedSharedWorkerStub::workerScriptLoaded().
   EXPECT_TRUE(
       renderer_host->OnMessageReceived(new WorkerHostMsg_WorkerConnected(
           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::vector<uint32_t>());
 
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
   connector->SendPostMessage("test1");
   EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host.get(), worker_msg_port_route_id, "test1");
 
   // When SharedWorker side sends MessagePortHostMsg_PostMessage,
   // SharedWorkerConnector side shuold receive MessagePortMsg_Message.
   const std::vector<int> empty_ports;
   EXPECT_TRUE(
       renderer_host->OnMessageReceived(new MessagePortHostMsg_PostMessage(
           connector->remote_port_id(),
           base::ASCIIToUTF16("test2"), empty_ports)));
   EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host.get(), connector->local_port_route_id(), "test2");
 
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature().
+  uint32_t feature1 = 124;
+  EXPECT_TRUE(renderer_host->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, feature1)));
+  EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
+  // ViewMsg_CountFeature should be sent to SharedWorkerConnector side.
+  CheckViewMsgCountFeature(renderer_host.get(), connector.get(), feature1);
+  // A message should be sent only one time per feature.
+  EXPECT_TRUE(renderer_host->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, feature1)));
+  EXPECT_EQ(0U, renderer_host->QueuedMessageCount());
+
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature() for another feature use.
+  uint32_t feature2 = 901;
+  EXPECT_TRUE(renderer_host->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, feature2)));
+  EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
+  // ViewMsg_CountFeature should be sent to SharedWorkerConnector side.
+  CheckViewMsgCountFeature(renderer_host.get(), connector.get(), feature2);
+
   // UpdateWorkerDependency should not be called.
   EXPECT_EQ(0, s_update_worker_dependency_call_count_);
 }
 
 TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) {
   // The first renderer host.
   std::unique_ptr<MockRendererProcessHost> renderer_host0(
       new MockRendererProcessHost(kProcessIDs[0],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
@@ skipping 57 matching lines @@
       new WorkerHostMsg_WorkerScriptLoaded(worker_route_id)));
   EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
 
   // SharedWorker sends WorkerHostMsg_WorkerConnected in
   // EmbeddedSharedWorkerStub::workerScriptLoaded().
   EXPECT_TRUE(
       renderer_host0->OnMessageReceived(new WorkerHostMsg_WorkerConnected(
           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::vector<uint32_t>());
 
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
   connector0->SendPostMessage("test1");
   EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host0.get(), worker_msg_port_route_id1, "test1");
 
   // When SharedWorker side sends MessagePortHostMsg_PostMessage,
   // SharedWorkerConnector side shuold receive MessagePortMsg_Message.
   const std::vector<int> empty_ports;
   EXPECT_TRUE(
       renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage(
           connector0->remote_port_id(),
           base::ASCIIToUTF16("test2"), empty_ports)));
   EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host0.get(), connector0->local_port_route_id(), "test2");
 
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature().
+  uint32_t feature1 = 124;
+  EXPECT_TRUE(renderer_host0->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, feature1)));
+  EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
+  // ViewMsg_CountFeature should be sent to SharedWorkerConnector side.
+  CheckViewMsgCountFeature(renderer_host0.get(), connector0.get(), feature1);
+  uint32_t feature2 = 901;
+  EXPECT_TRUE(renderer_host0->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, feature2)));
+  EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
+  // ViewMsg_CountFeature should be sent to SharedWorkerConnector side.
+  CheckViewMsgCountFeature(renderer_host0.get(), connector0.get(), feature2);
+
   // The second renderer host.
   std::unique_ptr<MockRendererProcessHost> renderer_host1(
       new MockRendererProcessHost(kProcessIDs[1],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
   std::unique_ptr<MockSharedWorkerConnector> connector1(
       new MockSharedWorkerConnector(renderer_host1.get()));
   int worker_msg_port_route_id2;
 
   // UpdateWorkerDependency should not be called yet.
@@ skipping 40 matching lines @@
   connector1->SendSendQueuedMessages(empty_messages);
   EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
 
   // SharedWorker sends WorkerHostMsg_WorkerConnected in
   // EmbeddedSharedWorkerStub::OnConnect().
   EXPECT_TRUE(
       renderer_host0->OnMessageReceived(new WorkerHostMsg_WorkerConnected(
           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(),
+                              {feature1, feature2});
 
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
   connector1->SendPostMessage("test3");
   EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host0.get(), worker_msg_port_route_id2, "test3");
 
   // When SharedWorker side sends MessagePortHostMsg_PostMessage,
   // SharedWorkerConnector side shuold receive MessagePortMsg_Message.
   EXPECT_TRUE(
       renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage(
           connector1->remote_port_id(),
           base::ASCIIToUTF16("test4"), empty_ports)));
   EXPECT_EQ(1U, renderer_host1->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host1.get(), connector1->local_port_route_id(), "test4");
 
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature(). These features 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, feature1)));
+  EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
+  EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
+
+  // SharedWorker sends WorkerHostMsg_CountFeature in
+  // EmbeddedSharedWorkerStub::CountFeature() for another feature use.
+  uint32_t feature3 = 1019;
+  EXPECT_TRUE(renderer_host0->OnMessageReceived(
+      new WorkerHostMsg_CountFeature(worker_route_id, feature3)));
+  // ViewMsg_CountFeature should be sent to all SharedWorkerConnectors
+  // connecting to this worker.
+  EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
+  CheckViewMsgCountFeature(renderer_host0.get(), connector0.get(), feature3);
+  EXPECT_EQ(1U, renderer_host1->QueuedMessageCount());
+  CheckViewMsgCountFeature(renderer_host1.get(), connector1.get(), feature3);
+
   EXPECT_EQ(1, s_update_worker_dependency_call_count_);
   renderer_host1.reset();
   // UpdateWorkerDependency should be called.
   EXPECT_EQ(2, s_update_worker_dependency_call_count_);
   EXPECT_EQ(0U, s_worker_dependency_added_ids_.size());
   EXPECT_EQ(1U, s_worker_dependency_removed_ids_.size());
   EXPECT_EQ(kProcessIDs[0], s_worker_dependency_removed_ids_[0]);
 }
 
 TEST_F(SharedWorkerServiceImplTest, CreateWorkerTest) {
@@ skipping 303 matching lines @@
                      kDocumentIDs[2],
                      kRenderFrameRouteIDs[2]);
   EXPECT_NE(MSG_ROUTING_NONE, connector2->route_id());
   EXPECT_EQ(0U, renderer_host2->QueuedMessageCount());
   RunAllPendingInMessageLoop();
   EXPECT_EQ(1U, renderer_host2->QueuedMessageCount());
   CheckViewMsgWorkerCreated(renderer_host2.get(), connector2.get());
 }
 
 }  // namespace content