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_status.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 335 matching lines @@
 void ServiceWorkerContextWrapper::DidFinishNavigationHintTaskOnUI(
     int render_process_id,
     const ResultCallback& callback,
     bool result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!--navigation_hint_task_count_per_process_[render_process_id])
     navigation_hint_task_count_per_process_.erase(render_process_id);
   callback.Run(result);
 }
 
+void ServiceWorkerContextWrapper::ExternalRequestErrorCallback(
+    int64_t service_worker_version_id,
+    const std::string& request_uuid,
+    ServiceWorkerStatusCode status) {
+  if (status != SERVICE_WORKER_OK) {
+    int request_id_not_used;
+    RemovePendingExternalRequest(service_worker_version_id, request_uuid,
+                                 &request_id_not_used);
+  }
+}
+
+bool ServiceWorkerContextWrapper::RemovePendingExternalRequest(
+    int64_t service_worker_version_id,
+    const std::string& request_uuid,
+    int* request_id) {

[Devlin, 2016/10/05 17:02:25]

drive-by nit: DCHECK(request_id)?

[lazyboy, 2016/10/06 01:02:06]

Obsolete /w the recent change suggested by michaeln@

+  RequestUUIDToRequestID& map_iter =
+      pending_external_requests_[service_worker_version_id];
+  RequestUUIDToRequestID::iterator iter = map_iter.find(request_uuid);
+  if (iter == map_iter.end())
+    return false;
+  *request_id = iter->second;

[michaeln, 2016/10/05 19:22:53]

where is .erase(iter)? i don't see where anything is removed from the inner or
outer maps.

[lazyboy, 2016/10/06 01:02:06]

Good catch, I might have dropped removing when uploading new patchsets.
Should be fixed with new approach.

+  return true;
+}
+
 bool ServiceWorkerContextWrapper::IsRunningNavigationHintTask(
     int render_process_id) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return base::ContainsKey(navigation_hint_task_count_per_process_,
                            render_process_id);
 }
 
 void ServiceWorkerContextWrapper::StartServiceWorker(
     const GURL& pattern,
     const StatusCallback& callback) {
@@ skipping 428 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::IncrementPendingActivity(
+    int64_t service_worker_version_id,
+    const std::string& request_uuid) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  ServiceWorkerVersion* version =
+      context()->GetLiveVersion(service_worker_version_id);
+  if (!version)
+    return false;
+
+  if (version->running_status() != EmbeddedWorkerStatus::RUNNING)

[Devlin, 2016/10/05 17:02:25]

Can this legitimately happen?  If so, how?  (Maybe add a comment?)  If not,
(D)CHECK?

[lazyboy, 2016/10/06 01:02:06]

Added comment.

+    return false;
+
+  int request_id = version->StartRequest(

[michaeln, 2016/10/05 19:22:53]

version->StartExternalRequest(uuid);  // no error callback required

the version deals with the book keeping, it might not even need a separate
mapping, it could iterate it's pending_requests_ map and find the EXTERNAL
reques with the matching uuid when FinishExternalRequest is called.

[lazyboy, 2016/10/06 01:02:06]

OK.
Moved the map inside ServiceWorkerVersion and exposed
bool StartExternalRequest and
bool FinishExternalRequest.

+      ServiceWorkerMetrics::EventType::EXTERNAL_REQUEST,
+      base::Bind(&ServiceWorkerContextWrapper::ExternalRequestErrorCallback,
+                 this, service_worker_version_id, request_uuid));
+  pending_external_requests_[service_worker_version_id].insert(
+      std::make_pair(request_uuid, request_id));
+  return true;
+}
+
+bool ServiceWorkerContextWrapper::DecrementPendingActivity(
+    int64_t service_worker_version_id,
+    const std::string& request_uuid) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  int request_id = -1;
+  bool had_request = RemovePendingExternalRequest(service_worker_version_id,
+                                                  request_uuid, &request_id);
+  if (!had_request) {
+    // It is possible that the request was cancelled or timed out before and we
+    // won't find it in |worker_requests|.
+    return true;  // Return true so we don't kill the process.
+  }
+
+  ServiceWorkerVersion* version =
+      context()->GetLiveVersion(service_worker_version_id);
+
+  // The service worker should be present and running.
+  if (!version || version->running_status() != EmbeddedWorkerStatus::RUNNING)

[Devlin, 2016/10/05 17:02:25]

ditto

[lazyboy, 2016/10/06 01:02:06]

Done.

+    return false;
+
+  return version->FinishRequest(request_id, true, base::Time::Now());

[michaeln, 2016/10/05 19:22:53]

version->FinishExternalRequest(uuid);

[lazyboy, 2016/10/06 01:02:06]

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