Add ref count to service workers for extension API.

extensions/browser/extension_function_dispatcher.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 "extensions/browser/extension_function_dispatcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/process/process.h"
 #include "base/profiler/scoped_profile.h"
 #include "base/scoped_observer.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/result_codes.h"
 #include "extensions/browser/api_activity_monitor.h"
 #include "extensions/browser/extension_function_registry.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/extension_util.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/io_thread_extension_message_filter.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/browser/quota_service.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/extensions_client.h"
 #include "ipc/ipc_message.h"
@@ skipping 422 matching lines @@
     return;
 
   UIThreadExtensionFunction* function_ui =
       function->AsUIThreadExtensionFunction();
   if (!function_ui) {
     NOTREACHED();
     return;
   }
   if (params.embedded_worker_id != -1) {
     function_ui->set_is_from_service_worker(true);
+    function_ui->set_embedded_worker_id(params.embedded_worker_id);
   } else {
     function_ui->SetRenderFrameHost(render_frame_host);
   }
   function_ui->set_dispatcher(AsWeakPtr());
   function_ui->set_browser_context(browser_context_);
   if (extension &&
       ExtensionsBrowserClient::Get()->CanExtensionCrossIncognito(
           extension, browser_context_)) {
     function->set_include_incognito(true);
   }
@@ skipping 48 matching lines @@
   // Check if extension was uninstalled by management.uninstall.
   if (!registry->enabled_extensions().GetByID(params.extension_id))
     return;
 
   // We only adjust the keepalive count for UIThreadExtensionFunction for
   // now, largely for simplicity's sake. This is OK because currently, only
   // the webRequest API uses IOThreadExtensionFunction, and that API is not
   // compatible with lazy background pages.
   // TODO(lazyboy): API functions from extension Service Worker will incorrectly
   // change keepalive count below.
-  process_manager->IncrementLazyKeepaliveCount(extension);
+  if (params.embedded_worker_id == -1) {
+    // Increment ref count for non-service worker extension API.
+    process_manager->IncrementLazyKeepaliveCount(extension);
+  } else {
+    // Increment ref count for service worker extension API.
+    LOG(ERROR) << "Increment ref count";
+    content::ServiceWorkerContext::IncrementEmbeddedWorkerRefCount(
+        extensions::util::GetStoragePartitionForExtensionId(params.extension_id,
+                                                            browser_context()),
+        params.embedded_worker_id);
+  }
 }
 
 void ExtensionFunctionDispatcher::RemoveWorkerCallbacksForProcess(
     int render_process_id) {
   UIThreadWorkerResponseCallbackWrapperMap& map =
       ui_thread_response_callback_wrappers_for_worker_;
   for (UIThreadWorkerResponseCallbackWrapperMap::iterator it = map.begin();
        it != map.end();) {
     if (it->first.render_process_id == render_process_id) {
       it = map.erase(it);
       continue;
     }
     ++it;
   }
 }
 
 void ExtensionFunctionDispatcher::OnExtensionFunctionCompleted(
-    const Extension* extension) {
-  // TODO(lazyboy): API functions from extension Service Worker will incorrectly
-  // change keepalive count below.
+    const Extension* extension,
+    int embedded_worker_id) {
   if (extension) {
-    ProcessManager::Get(browser_context_)
-        ->DecrementLazyKeepaliveCount(extension);
+    if (embedded_worker_id == -1) {
+      // Decrement ref count for non-service worker extension API.
+      ProcessManager::Get(browser_context_)
+          ->DecrementLazyKeepaliveCount(extension);
+    } else {
+      // Decrement ref count for service worker extension API.
+      LOG(ERROR) << "Decrement ref count.";
+      content::ServiceWorkerContext::DecrementEmbeddedWorkerRefCount(
+          extensions::util::GetStoragePartitionForExtensionId(extension->id(),
+                                                              browser_context_),
+          embedded_worker_id);
+    }
   }
 }
 
 WindowController*
 ExtensionFunctionDispatcher::GetExtensionWindowController() const {
   return delegate_ ? delegate_->GetExtensionWindowController() : nullptr;
 }
 
 content::WebContents*
 ExtensionFunctionDispatcher::GetAssociatedWebContents() const {
@@ skipping 55 matching lines @@
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     const ExtensionFunction::ResponseCallback& callback,
     functions::HistogramValue histogram_value) {
   base::ListValue empty_list;
   callback.Run(ExtensionFunction::FAILED, empty_list,
                "Access to extension API denied.", histogram_value);
 }
 
 }  // namespace extensions