Add ref count to service workers for extension API.

content/browser/service_worker/service_worker_context_wrapper.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_CONTEXT_WRAPPER_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 94 matching lines @@
       const GURL& url,
       const GURL& other_url,
       const CheckHasServiceWorkerCallback& callback) override;
   void StopAllServiceWorkersForOrigin(const GURL& origin) override;
   void ClearAllServiceWorkersForTest(const base::Closure& callback) override;
   void StartServiceWorkerForNavigationHint(
       const GURL& document_url,
       blink::WebNavigationHintType type,
       int render_process_id,
       const ResultCallback& callback) override;
+  bool IncrementPendingActivity(int64_t service_worker_version_id,
+                                const std::string& request_uuid) override;
+  bool DecrementPendingActivity(int64_t service_worker_version_id,
+                                const std::string& request_uuid) override;
 
   // These methods must only be called from the IO thread.
   ServiceWorkerRegistration* GetLiveRegistration(int64_t registration_id);
   ServiceWorkerVersion* GetLiveVersion(int64_t version_id);
   std::vector<ServiceWorkerRegistrationInfo> GetAllLiveRegistrationInfo();
   std::vector<ServiceWorkerVersionInfo> GetAllLiveVersionInfo();
 
   // Must be called from the IO thread.
   void HasMainFrameProviderHost(const GURL& origin,
                                 const BoolCallback& callback) const;
@@ skipping 64 matching lines @@
   bool OriginHasForeignFetchRegistrations(const GURL& origin);
 
   // Must be called from the UI thread.
   bool IsRunningNavigationHintTask(int render_process_id) const;
 
  private:
   friend class BackgroundSyncManagerTest;
   friend class base::RefCountedThreadSafe<ServiceWorkerContextWrapper>;
   friend class EmbeddedWorkerTestHelper;
   friend class EmbeddedWorkerBrowserTest;
+  friend class ServiceWorkerContext;

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

is this needed?

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

Not anymore, removed.

   friend class ServiceWorkerDispatcherHost;
   friend class ServiceWorkerInternalsUI;
   friend class ServiceWorkerNavigationHandleCore;
   friend class ServiceWorkerProcessManager;
   friend class ServiceWorkerRequestHandler;
   friend class ServiceWorkerVersionBrowserTest;
   friend class MockServiceWorkerContextWrapper;
 
   ~ServiceWorkerContextWrapper() override;
 
@@ skipping 40 matching lines @@
       scoped_refptr<ServiceWorkerRegistration> registration);
 
   void DidStartServiceWorkerForNavigationHint(const GURL& pattern,
                                               int render_process_id,
                                               const ResultCallback& callback,
                                               ServiceWorkerStatusCode code);
   void DidFinishNavigationHintTaskOnUI(int render_process_id,
                                        const ResultCallback& callback,
                                        bool result);
 
+  void ExternalRequestErrorCallback(int64_t service_worker_version_id,

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

drive-by: function comment?

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

Obsolete now with new patch.

+                                    const std::string& request_uuid,
+                                    ServiceWorkerStatusCode status);
+
+  // Removes a pending external request identified by |request_uuid|.
+  // Returns true if the request was found. Also returns |request_id| in that
+  // case.
+  bool RemovePendingExternalRequest(int64_t service_worker_version_id,
+                                    const std::string& request_uuid,
+                                    int* request_id);
+
   // The core context is only for use on the IO thread.
   // Can be null before/during init, during/after shutdown, and after
   // DeleteAndStartOver fails.
   ServiceWorkerContextCore* context();
 
   const scoped_refptr<base::ObserverListThreadSafe<
       ServiceWorkerContextObserver>> observer_list_;
   const std::unique_ptr<ServiceWorkerProcessManager> process_manager_;
   // Cleared in ShutdownOnIO():
   std::unique_ptr<ServiceWorkerContextCore> context_core_;
 
   // Initialized in Init(); true if the user data directory is empty.
   bool is_incognito_;
 
   // Raw pointer to the StoragePartitionImpl owning |this|.
   StoragePartitionImpl* storage_partition_;
 
   // The ResourceContext associated with this context.
   ResourceContext* resource_context_;
 
   // Must be touched on the UI thread.
   std::map<int, int> navigation_hint_task_count_per_process_;
 
+  // Container for pending external requests of a service worker.
+  // Each request is (key, value): (request uuid, request id).
+  using RequestUUIDToRequestID = std::map<std::string, int>;
+  // Maps service worker version id -> RequestUUIDToRequestID.
+  // IO thread.
+  std::map<int64_t, RequestUUIDToRequestID> pending_external_requests_;

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

Please consider moving this mapping of external_request_uuid to
internal_integer_id into the ServiceWorkerVersion class proper, and making that
class be responsible for cleanup in all cases, whether it be request completes
or the renderer crashes for any reason the Version goes away.

aside: The original intent of the wrapper was to contain as little logic as
possible and just to provide 'shimware' from UI thread to IO thread for the
content lib internals, and for shimware bewteen public content api and the
actual impl (this cl's use case).

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

Done.

+
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerContextWrapper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_