Add ref count to service workers for extension API.

content/browser/service_worker/service_worker_version.cc

Index: content/browser/service_worker/service_worker_version.cc
diff --git a/content/browser/service_worker/service_worker_version.cc b/content/browser/service_worker/service_worker_version.cc
index 337e676375282f1ea3cf4ccee6738d735cd5aef8..05dbaccf276a7637b29e9e257ea0deea7522497d 100644
--- a/content/browser/service_worker/service_worker_version.cc
+++ b/content/browser/service_worker/service_worker_version.cc
@@ -564,6 +564,21 @@ int ServiceWorkerVersion::StartRequestWithCustomTimeout(
   return request_id;
 }
 
+bool ServiceWorkerVersion::StartExternalRequest(
+    const std::string& request_uuid) {
+  // It's possible that the renderer is lying or the version started stopping
+  // right around the time of the IPC.
+  if (running_status() != EmbeddedWorkerStatus::RUNNING)
+    return false;
+
+  int request_id =
+      StartRequest(ServiceWorkerMetrics::EventType::EXTERNAL_REQUEST,
+                   base::Bind(&ServiceWorkerVersion::CleanUpExternalRequest,
+                              this, request_uuid));
+  external_request_uuid_to_request_id_[request_uuid] = request_id;
+  return true;
+}
+
 bool ServiceWorkerVersion::FinishRequest(int request_id,
                                          bool was_handled,
                                          base::Time dispatch_event_time) {
@@ -589,6 +604,27 @@ bool ServiceWorkerVersion::FinishRequest(int request_id,
   return true;
 }
 
+bool ServiceWorkerVersion::FinishExternalRequest(
+    const std::string& request_uuid) {
+  // It's possible that the renderer is lying or the version started stopping
+  // right around the time of the IPC.
+  if (running_status() != EmbeddedWorkerStatus::RUNNING)
+    return false;
+
+  RequestUUIDToRequestIDMap::iterator iter =
+      external_request_uuid_to_request_id_.find(request_uuid);
+  if (iter != external_request_uuid_to_request_id_.end()) {
+    int request_id = iter->second;
+    external_request_uuid_to_request_id_.erase(iter);
+    return FinishRequest(request_id, true, base::Time::Now());
+  }
+
+  // It is possible that the request was cancelled or timed out before and we
+  // won't find it in |external_request_uuid_to_request_id_|.
+  // Return true so we don't kill the process.
+  return true;
+}
+
 void ServiceWorkerVersion::RunAfterStartWorker(
     ServiceWorkerMetrics::EventType purpose,
     const base::Closure& task,
@@ -1765,6 +1801,7 @@ void ServiceWorkerVersion::OnStoppedInternal(EmbeddedWorkerStatus old_status) {
     iter.Advance();
   }
   pending_requests_.Clear();
+  external_request_uuid_to_request_id_.clear();

[Devlin, 2016/10/07 15:13:22]

For my own edification, how can the SW be stopped when there are external jobs?

[falken, 2016/10/07 15:22:03]

It could be intentional: the browser process kills the SW if the request is
taking too long (5 min timeout) or if the SW is apparently in a busy loop and
unresponsive to pings (30 sec timeout). It's also conceivable something went
awry and for whatever reason the renderer process or SW thread died
unexpectedly.

[Devlin, 2016/10/07 15:46:37]

Couple of thoughts here (not necessarily ones that need to be addressed in this
CL).  What happens if an extension function round trip takes > 5 minutes?  This
could legitimately happen if e.g. the extension uses an API that shows a dialog
to the user and the user walks away.  For one thing, it sounds like the browser
would kill the SW then - which isn't necessarily the right thing to do.  For
another, assuming the entire process isn't killed, the browser would respond
once the user comes back, and the renderer might try to a) possibly call into
the dead context and b) respond to decrement the (already dead) SW - which now
would kill the renderer.

[lazyboy, 2016/10/07 18:50:10]

Interesting, we definitely need to tackle this 5 min issue going forward. File a
bug to track?

[Devlin, 2016/10/07 19:06:44]

Yeah, I think it's fine to land this part, since this is all still behind trunk.

 
   // Close all mojo services. This will also fire and clear all callbacks
   // for messages that are still outstanding for those services.
@@ -1801,4 +1838,12 @@ void ServiceWorkerVersion::FinishStartWorker(ServiceWorkerStatusCode status) {
   RunCallbacks(this, &start_callbacks_, status);
 }
 
+void ServiceWorkerVersion::CleanUpExternalRequest(
+    const std::string& request_uuid,
+    ServiceWorkerStatusCode status) {
+  if (status == SERVICE_WORKER_OK)
+    return;
+  external_request_uuid_to_request_id_.erase(request_uuid);
+}
+
 }  // namespace content