ServiceWorker: Enable UseCounter for ServiceWorkerGlobalScope

content/child/service_worker/service_worker_dispatcher_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 "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "content/child/service_worker/service_worker_dispatcher.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
 #include "content/child/service_worker/web_service_worker_impl.h"
@@ skipping 68 matching lines @@
     dispatcher_->OnAssociateRegistration(thread_id, provider_id, info, attrs);
   }
 
   void OnDisassociateRegistration(int thread_id, int provider_id) {
     dispatcher_->OnDisassociateRegistration(thread_id, provider_id);
   }
 
   void OnSetControllerServiceWorker(int thread_id,
                                     int provider_id,
                                     const ServiceWorkerObjectInfo& info,
-                                    bool should_notify_controllerchange) {
+                                    bool should_notify_controllerchange,
+                                    const std::set<uint32_t>& used_features) {
     dispatcher_->OnSetControllerServiceWorker(thread_id, provider_id, info,
-                                              should_notify_controllerchange);
+                                              should_notify_controllerchange,
+                                              used_features);
   }
 
   void OnPostMessage(const ServiceWorkerMsg_MessageToDocument_Params& params) {
     dispatcher_->OnPostMessage(params);
   }
 
   std::unique_ptr<ServiceWorkerHandleReference> Adopt(
       const ServiceWorkerObjectInfo& info) {
     return dispatcher_->Adopt(info);
   }
@@ skipping 33 matching lines @@
 
   void dispatchMessageEvent(
       std::unique_ptr<blink::WebServiceWorker::Handle> handle,
       const blink::WebString& message,
       const blink::WebMessagePortChannelArray& channels) override {
     // WebPassOwnPtr cannot be owned in Chromium, so drop the handle here.
     // The destruction releases ServiceWorkerHandleReference.
     is_dispatch_message_event_called_ = true;
   }
 
+  void countFeature(uint32_t feature) override {
+    used_features_.insert(feature);
+  }
+
   bool is_set_controlled_called() const { return is_set_controlled_called_; }
 
   bool is_dispatch_message_event_called() const {
     return is_dispatch_message_event_called_;
   }
 
  private:
   const int provider_id_;
   bool is_set_controlled_called_ = false;
   bool is_dispatch_message_event_called_ = false;
   ServiceWorkerDispatcher* dispatcher_;
+  std::set<uint32_t> used_features_;
 };
 
 TEST_F(ServiceWorkerDispatcherTest, OnAssociateRegistration_NoProviderContext) {
   // Assume that these objects are passed from the browser process and own
   // references to browser-side registration/worker representations.
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   CreateObjectInfoAndVersionAttributes(&info, &attrs);
 
   // The passed references should be adopted but immediately released because
@@ skipping 86 matching lines @@
   // Assume that these objects are passed from the browser process and own
   // references to browser-side registration/worker representations.
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   CreateObjectInfoAndVersionAttributes(&info, &attrs);
 
   // (1) In the case there are no SWProviderContext and WebSWProviderClient for
   // the provider, the passed reference to the active worker should be adopted
   // but immediately released because there is no provider context to own it.
   OnSetControllerServiceWorker(kDocumentMainThreadId, kProviderId, attrs.active,
-                               should_notify_controllerchange);
+                               should_notify_controllerchange,
+                               std::set<uint32_t>());
   ASSERT_EQ(1UL, ipc_sink()->message_count());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(0)->type());
   ipc_sink()->ClearMessages();
 
   // (2) In the case there is no WebSWProviderClient but SWProviderContext for
   // the provider, the passed referecence should be adopted and owned by the
   // provider context.
   scoped_refptr<ServiceWorkerProviderContext> provider_context(
       new ServiceWorkerProviderContext(kProviderId,
                                        SERVICE_WORKER_PROVIDER_FOR_WINDOW,
                                        thread_safe_sender()));
   OnAssociateRegistration(kDocumentMainThreadId, kProviderId, info, attrs);
   ipc_sink()->ClearMessages();
   OnSetControllerServiceWorker(kDocumentMainThreadId, kProviderId, attrs.active,
-                               should_notify_controllerchange);
+                               should_notify_controllerchange,
+                               std::set<uint32_t>());
   EXPECT_EQ(0UL, ipc_sink()->message_count());
 
   // Destruction of the provider context should release references to the
   // associated registration and the controller.
   provider_context = nullptr;
   ASSERT_EQ(2UL, ipc_sink()->message_count());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(0)->type());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementRegistrationRefCount::ID,
             ipc_sink()->GetMessageAt(1)->type());
   ipc_sink()->ClearMessages();
 
   // (3) In the case there is no SWProviderContext but WebSWProviderClient for
   // the provider, the new reference should be created and owned by the provider
   // client (but the reference is immediately released due to limitation of the
   // mock provider client. See the comment on setController() of the mock).
   // In addition, the passed reference should be adopted but immediately
   // released because there is no provider context to own it.
   std::unique_ptr<MockWebServiceWorkerProviderClientImpl> provider_client(
       new MockWebServiceWorkerProviderClientImpl(kProviderId, dispatcher()));
   ASSERT_FALSE(provider_client->is_set_controlled_called());
   OnSetControllerServiceWorker(kDocumentMainThreadId, kProviderId, attrs.active,
-                               should_notify_controllerchange);
+                               should_notify_controllerchange,
+                               std::set<uint32_t>());
   EXPECT_TRUE(provider_client->is_set_controlled_called());
   ASSERT_EQ(3UL, ipc_sink()->message_count());
   EXPECT_EQ(ServiceWorkerHostMsg_IncrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(0)->type());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(1)->type());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(2)->type());
   provider_client.reset();
   ipc_sink()->ClearMessages();
 
   // (4) In the case there are both SWProviderContext and SWProviderClient for
   // the provider, the passed referecence should be adopted and owned by the
   // provider context. In addition, the new reference should be created for the
   // provider client and immediately released due to limitation of the mock
   // implementation.
   provider_context = new ServiceWorkerProviderContext(
       kProviderId, SERVICE_WORKER_PROVIDER_FOR_WINDOW, thread_safe_sender());
   OnAssociateRegistration(kDocumentMainThreadId, kProviderId, info, attrs);
   provider_client.reset(
       new MockWebServiceWorkerProviderClientImpl(kProviderId, dispatcher()));
   ASSERT_FALSE(provider_client->is_set_controlled_called());
   ipc_sink()->ClearMessages();
   OnSetControllerServiceWorker(kDocumentMainThreadId, kProviderId, attrs.active,
-                               should_notify_controllerchange);
+                               should_notify_controllerchange,
+                               std::set<uint32_t>());
   EXPECT_TRUE(provider_client->is_set_controlled_called());
   ASSERT_EQ(2UL, ipc_sink()->message_count());
   EXPECT_EQ(ServiceWorkerHostMsg_IncrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(0)->type());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(1)->type());
 }
 
 // Test that clearing the controller by sending a kInvalidServiceWorkerHandle
 // results in the provider context having a null controller.
 TEST_F(ServiceWorkerDispatcherTest, OnSetControllerServiceWorker_Null) {
   const int kProviderId = 10;
   bool should_notify_controllerchange = true;
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   CreateObjectInfoAndVersionAttributes(&info, &attrs);
 
   std::unique_ptr<MockWebServiceWorkerProviderClientImpl> provider_client(
       new MockWebServiceWorkerProviderClientImpl(kProviderId, dispatcher()));
   scoped_refptr<ServiceWorkerProviderContext> provider_context(
       new ServiceWorkerProviderContext(kProviderId,
                                        SERVICE_WORKER_PROVIDER_FOR_WINDOW,
                                        thread_safe_sender()));
 
   OnAssociateRegistration(kDocumentMainThreadId, kProviderId, info, attrs);
 
   // Set the controller to kInvalidServiceWorkerHandle.
-  OnSetControllerServiceWorker(kDocumentMainThreadId, kProviderId,
-                               ServiceWorkerObjectInfo(),
-                               should_notify_controllerchange);
+  OnSetControllerServiceWorker(
+      kDocumentMainThreadId, kProviderId, ServiceWorkerObjectInfo(),
+      should_notify_controllerchange, std::set<uint32_t>());
 
   // Check that it became null.
   EXPECT_EQ(nullptr, provider_context->controller());
   EXPECT_TRUE(provider_client->is_set_controlled_called());
 }
 
 TEST_F(ServiceWorkerDispatcherTest, OnPostMessage) {
   const int kProviderId = 10;
 
   // Assume that these objects are passed from the browser process and own
@@ skipping 147 matching lines @@
             ipc_sink()->GetMessageAt(0)->type());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(1)->type());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementServiceWorkerRefCount::ID,
             ipc_sink()->GetMessageAt(2)->type());
   EXPECT_EQ(ServiceWorkerHostMsg_DecrementRegistrationRefCount::ID,
             ipc_sink()->GetMessageAt(3)->type());
 }
 
 }  // namespace content