Add ref count to service workers for extension API.

content/browser/service_worker/service_worker_context_wrapper.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_context_wrapper.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_quota_client.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 14 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
 }
 
 void WorkerStarted(const ServiceWorkerContextWrapper::StatusCallback& callback,
                    ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, status));
 }
 
+void DoNothing(ServiceWorkerStatusCode status) {}

[falken, 2016/09/23 02:27:35]

you can use ServiceWorkerUtils::NoOpStatusCallback

[lazyboy, 2016/09/27 21:26:45]

Done.

+
 void StartActiveWorkerOnIO(
     const ServiceWorkerContextWrapper::StatusCallback& callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status == SERVICE_WORKER_OK) {
     // Pass the reference of |registration| to WorkerStarted callback to prevent
     // it from being deleted while starting the worker. If the refcount of
     // |registration| is 1, it will be deleted after WorkerStarted is called.
     registration->active_version()->StartWorker(
@@ skipping 26 matching lines @@
           NAVIGATION_HINT_LINK_TAP_UNCONFIRMED;
     case blink::WebNavigationHintType::LinkTapDown:
       return ServiceWorkerMetrics::EventType::NAVIGATION_HINT_LINK_TAP_DOWN;
   }
   NOTREACHED() << "Unexpected navigation hint" << static_cast<int>(type);
   return ServiceWorkerMetrics::EventType::UNKNOWN;
 }
 
 }  // namespace
 
+bool ServiceWorkerContextWrapper::IncrementPendingActivity(
+    int64_t service_worker_version_id) {
+  return IncrementPendingActivityOnIO(service_worker_version_id);

[falken, 2016/09/23 02:27:35]

Can the *OnIO functions just be removed?

[lazyboy, 2016/09/27 21:26:45]

Oh yes, these used to do thread hops, done.

+}
+
+bool ServiceWorkerContextWrapper::DecrementPendingActivity(
+    int64_t service_worker_version_id) {
+  return DecrementPendingActivityOnIO(service_worker_version_id);
+}
+
 void ServiceWorkerContext::AddExcludedHeadersForFetchEvent(
     const std::set<std::string>& header_names) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "477117 ServiceWorkerContext::AddExcludedHeadersForFetchEvent"));
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   g_excluded_header_name_set.Get().insert(header_names.begin(),
                                           header_names.end());
 }
@@ skipping 703 matching lines @@
       user_data_directory, std::move(database_task_manager), disk_cache_thread,
       quota_manager_proxy, special_storage_policy, observer_list_.get(), this));
 }
 
 void ServiceWorkerContextWrapper::ShutdownOnIO() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   resource_context_ = nullptr;
   context_core_.reset();
 }
 
+bool ServiceWorkerContextWrapper::IncrementPendingActivityOnIO(
+    int64_t service_worker_version_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  ServiceWorkerVersion* version =
+      context()->GetLiveVersion(service_worker_version_id);
+  if (!version) {

[falken, 2016/09/23 02:27:35]

You should also confirm the version is RUNNING. It's possible the renderer is
confused/lying or the version started stopping right around the time of the IPC.

[lazyboy, 2016/09/27 21:26:45]

Done.

+    LOG(WARNING) << "ServiceWorkerVersion not found: "
+                 << service_worker_version_id;

[falken, 2016/09/23 02:27:35]

do you need these logs in production code? DVLOG(1)?

[lazyboy, 2016/09/27 21:26:45]

No, changed to DVLOG, thanks.

+    return false;
+  }
+  int request_id =
+      version->StartRequest(ServiceWorkerMetrics::EventType::EXTERNAL_REQUEST,
+                            base::Bind(&DoNothing));
+  pending_external_requests_[service_worker_version_id].insert(request_id);
+  return true;
+}
+
+bool ServiceWorkerContextWrapper::DecrementPendingActivityOnIO(
+    int64_t service_worker_version_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  ServiceWorkerVersion* version =
+      context()->GetLiveVersion(service_worker_version_id);
+  if (!version) {

[falken, 2016/09/23 02:27:35]

I'm not too sure when we get in this state: the renderer might have made a
mistake or the version might have been destructed due to some timing issue. We
should probably clean up the pending_external_requests  in this case though. Or
maybe the set of external requests should just be in ServiceWorkerVersion?

Also, the case where the version is not RUNNING should probably be handled.

[lazyboy, 2016/09/27 21:26:45]

Changed to DCHECK. This could uncover any timing issue we might have...

We
Done.

Or
Done.

+    LOG(WARNING) << "ServiceWorkerVersion not found: "
+                 << service_worker_version_id;
+    return false;
+  }
+  std::set<int>& pending_requests =
+      pending_external_requests_[service_worker_version_id];
+  DCHECK(pending_requests.size() > 0);
+  int request_id = *pending_requests.begin();
+  pending_requests.erase(request_id);
+  version->FinishRequest(request_id, true, base::Time::Now());
+  return true;

[falken, 2016/09/23 02:27:35]

This ignores FinishRequest's return value. Maybe it should be used?

[lazyboy, 2016/09/27 21:26:45]

Done.

+}
+
 void ServiceWorkerContextWrapper::DidDeleteAndStartOver(
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     context_core_.reset();
     return;
   }
   context_core_.reset(new ServiceWorkerContextCore(context_core_.get(), this));
   DVLOG(1) << "Restarted ServiceWorkerContextCore successfully.";
 
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnStorageWiped);
 }
 
 ServiceWorkerContextCore* ServiceWorkerContextWrapper::context() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return context_core_.get();
 }
 
 }  // namespace content