Worker: Enable UseCounter for SharedWorkerGlobalScope

content/browser/shared_worker/shared_worker_host.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_host.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/message_port_service.h"
@@ skipping 112 matching lines @@
                                            int render_frame_id) {
   // Walk all instances and remove all the documents in the frame from their
   // document set.
   worker_document_set_->RemoveRenderFrame(render_process_id, render_frame_id);
   if (worker_document_set_->IsEmpty()) {
     // This worker has no more associated documents - shut it down.
     TerminateWorker();
   }
 }
 
+void SharedWorkerHost::CountFeature(uint32_t feature) {
+  if (!use_counter_.insert(feature).second)
+    return;
+  for (const auto& filter_info : filters_) {
+    filter_info.filter()->Send(new ViewMsg_CountFeatureOnSharedWorker(
+        filter_info.route_id(), feature));
+  }
+}
+
 void SharedWorkerHost::WorkerContextClosed() {
   // Set the closed flag - this will stop any further messages from
   // being sent to the worker (messages can still be sent from the worker,
   // for exception reporting, etc).
   closed_ = true;
   if (!termination_message_sent_)
     NotifyWorkerDestroyed(worker_process_id_, worker_route_id_);
 }
 
+void SharedWorkerHost::WorkerContextDestroyed() {
+  for (const auto& filter_info : filters_) {
+    filter_info.filter()->Send(
+        new ViewMsg_WorkerDestroyed(filter_info.route_id()));
+  }
+}
+
 void SharedWorkerHost::WorkerReadyForInspection() {
   NotifyWorkerReadyForInspection(worker_process_id_, worker_route_id_);
 }
 
 void SharedWorkerHost::WorkerScriptLoaded() {
   UMA_HISTOGRAM_TIMES("SharedWorker.TimeToScriptLoaded",
                       base::TimeTicks::Now() - creation_time_);
 }
 
 void SharedWorkerHost::WorkerScriptLoadFailed() {
   UMA_HISTOGRAM_TIMES("SharedWorker.TimeToScriptLoadFailed",
                       base::TimeTicks::Now() - creation_time_);
   for (const FilterInfo& info : filters_)
     info.filter()->Send(new ViewMsg_WorkerScriptLoadFailed(info.route_id()));
 }
 
 void SharedWorkerHost::WorkerConnected(int message_port_id) {
   for (const FilterInfo& info : filters_) {
     if (info.message_port_id() != message_port_id)
       continue;
-    info.filter()->Send(new ViewMsg_WorkerConnected(info.route_id()));
+    info.filter()->Send(
+        new ViewMsg_WorkerConnected(info.route_id(), use_counter_));
     return;
   }
 }
 
 void SharedWorkerHost::AllowFileSystem(
     const GURL& url,
     std::unique_ptr<IPC::Message> reply_msg) {
   GetContentClient()->browser()->AllowWorkerFileSystem(
       url,
       instance_->resource_context(),
@@ skipping 98 matching lines @@
       return;
     }
   }
 }
 
 bool SharedWorkerHost::Send(IPC::Message* message) {
   return worker_render_filter_->Send(message);
 }
 
 }  // namespace content