ServiceWorker: Enable UseCounter for ServiceWorkerGlobalScope

content/browser/service_worker/service_worker_provider_host.cc

 // Copyright 2013 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/service_worker/service_worker_provider_host.h"
 
 #include <utility>
 
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
@@ skipping 230 matching lines @@
   if (previous_version.get())
     previous_version->RemoveControllee(this);
 
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   // SetController message should be sent only for controllees.
   DCHECK(IsProviderForClient());
   Send(new ServiceWorkerMsg_SetControllerServiceWorker(
       render_thread_id_, provider_id(), GetOrCreateServiceWorkerHandle(version),
-      notify_controllerchange));
+      notify_controllerchange,
+      version ? version->used_features() : std::set<uint32_t>()));
 }
 
 void ServiceWorkerProviderHost::SetHostedVersion(
     ServiceWorkerVersion* version) {
   DCHECK(!IsProviderForClient());
   DCHECK_EQ(EmbeddedWorkerStatus::STARTING, version->running_status());
   DCHECK_EQ(render_process_id_, version->embedded_worker()->process_id());
   running_hosted_version_ = version;
 }
 
@@ skipping 190 matching lines @@
   ServiceWorkerMsg_MessageToDocument_Params params;
   params.thread_id = kDocumentMainThreadId;
   params.provider_id = provider_id();
   params.service_worker_info = GetOrCreateServiceWorkerHandle(version);
   params.message = message;
   params.message_ports = sent_message_ports;
   params.new_routing_ids = new_routing_ids;
   Send(new ServiceWorkerMsg_MessageToDocument(params));
 }
 
+void ServiceWorkerProviderHost::CountFeature(uint32_t feature) {
+  if (!dispatcher_host_)
+    return;  // Could be nullptr in some tests.
+
+  // CountFeature message should be sent only for controllees.
+  DCHECK(IsProviderForClient());
+  Send(new ServiceWorkerMsg_CountFeature(render_thread_id_, provider_id(),
+                                         feature));
+}
+
 void ServiceWorkerProviderHost::AddScopedProcessReferenceToPattern(
     const GURL& pattern) {
   associated_patterns_.push_back(pattern);
   IncreaseProcessReference(pattern);
 }
 
 void ServiceWorkerProviderHost::ClaimedByRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(registration->active_version());
   if (registration == associated_registration_) {
@@ skipping 252 matching lines @@
   for (auto& key_registration : matching_registrations_)
     IncreaseProcessReference(key_registration.second->pattern());
 
   if (associated_registration_.get()) {
     SendAssociateRegistrationMessage();
     if (dispatcher_host_ && associated_registration_->active_version()) {
       Send(new ServiceWorkerMsg_SetControllerServiceWorker(
           render_thread_id_, provider_id(),
           GetOrCreateServiceWorkerHandle(
               associated_registration_->active_version()),
-          false /* shouldNotifyControllerChange */));
+          false /* shouldNotifyControllerChange */,
+          associated_registration_->active_version()->used_features()));
     }
   }
 }
 
 }  // namespace content