Add ref count to service workers for extension API.

content/browser/service_worker/service_worker_version.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 
 #include <stdint.h>
 
 #include <functional>
@@ skipping 217 matching lines @@
   int StartRequest(ServiceWorkerMetrics::EventType event_type,
                    const StatusCallback& error_callback);
 
   // Same as StartRequest, but allows the caller to specify a custom timeout for
   // the event, as well as the behavior for when the request times out.
   int StartRequestWithCustomTimeout(ServiceWorkerMetrics::EventType event_type,
                                     const StatusCallback& error_callback,
                                     const base::TimeDelta& timeout,
                                     TimeoutBehavior timeout_behavior);
 
+  // Starts a request of type EventType::EXTERNAL_REQUEST.
+  // Provides a mechanism to external clients to keep the worker running.
+  // |request_uuid| is a GUID for clients to identify the request.
+  bool StartExternalRequest(const std::string& request_uuid);
+
   // Informs ServiceWorkerVersion that an event has finished being dispatched.
   // Returns false if no pending requests with the provided id exist, for
   // example if the request has already timed out.
   // Pass the result of the event to |was_handled|, which is used to record
   // statistics based on the event status.
   // TODO(mek): Use something other than a bool for event status.
   bool FinishRequest(int request_id,
                      bool was_handled,
                      base::Time dispatch_event_time);
 
+  // Finishes an external request that was started by StartExternalRequest().
+  bool FinishExternalRequest(const std::string& request_uuid);
+
   // Connects to a specific mojo service exposed by the (running) service
   // worker. If a connection to a service for the same Interface already exists
   // this will return that existing connection. The |request_id| must be a value
   // previously returned by StartRequest. If the connection to the service
   // fails or closes before the request finished, the error callback associated
   // with |request_id| is called.
   // Only call GetMojoServiceForRequest once for a specific |request_id|.
   template <typename Interface>
   base::WeakPtr<Interface> GetMojoServiceForRequest(int request_id);
 
@@ skipping 416 matching lines @@
 
   // Called at the beginning of each Dispatch*Event function: records
   // the time elapsed since idle (generally the time since the previous
   // event ended).
   void OnBeginEvent();
 
   // Resets |start_worker_first_purpose_| and fires and clears all start
   // callbacks.
   void FinishStartWorker(ServiceWorkerStatusCode status);
 
+  // Removes any pending external request that has GUID of |request_uuid|.
+  void CleanUpExternalRequest(const std::string& request_uuid,
+                              ServiceWorkerStatusCode status);
+
   const int64_t version_id_;
   const int64_t registration_id_;
   const GURL script_url_;
   const GURL scope_;
   std::vector<GURL> foreign_fetch_scopes_;
   std::vector<url::Origin> foreign_fetch_origins_;
   FetchHandlerExistence fetch_handler_existence_;
   ServiceWorkerMetrics::Site site_for_uma_;
 
   Status status_ = NEW;
   std::unique_ptr<EmbeddedWorkerInstance> embedded_worker_;
   std::vector<StatusCallback> start_callbacks_;
   std::vector<StatusCallback> stop_callbacks_;
   std::vector<base::Closure> status_change_callbacks_;
 
   // Holds in-flight requests, including requests due to outstanding push,
   // fetch, sync, etc. events.
   IDMap<PendingRequest, IDMapOwnPointer> pending_requests_;
 
+  // Container for pending external requests for this service worker.
+  // (key, value): (request uuid, request id).
+  using RequestUUIDToRequestIDMap = std::map<std::string, int>;
+  RequestUUIDToRequestIDMap external_request_uuid_to_request_id_;
+
   // Stores all open connections to mojo services. Maps the service name to
   // the actual interface pointer. When a connection is closed it is removed
   // from this map.
   // mojo_services_[Interface::Name_] is assumed to always contain a
   // MojoServiceWrapper<Interface> instance.
   base::ScopedPtrHashMap<const char*, std::unique_ptr<BaseMojoServiceWrapper>>
       mojo_services_;
 
   std::set<const ServiceWorkerURLRequestJob*> streaming_url_request_jobs_;
 
@@ skipping 125 matching lines @@
 
   // At this point |this| can have been deleted, so don't do anything other
   // than returning.
 
   return true;
 }
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_