ServiceWorker: Make "ready" fetches registration from browser process(2/3).

content/browser/service_worker/service_worker_provider_host.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_PROVIDER_HOST_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_HOST_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 30 matching lines @@
 //
 // Note this class can also host a running service worker, in which
 // case it will observe resource loads made directly by the service worker.
 class CONTENT_EXPORT ServiceWorkerProviderHost
     : public NON_EXPORTED_BASE(ServiceWorkerRegistration::Listener),
       public base::SupportsWeakPtr<ServiceWorkerProviderHost> {
  public:
   using FocusCallback = base::Callback<void(bool)>;
   using GetClientInfoCallback =
       base::Callback<void(const ServiceWorkerClientInfo&)>;
+  using GetReadyRegistrationCallback =
+      base::Callback<void(ServiceWorkerRegistration* reigstration)>;
 
   // If |render_frame_id| is MSG_ROUTING_NONE, this provider host works for the
   // worker context.
   ServiceWorkerProviderHost(int render_process_id,
                             int render_frame_id,
                             int provider_id,
                             base::WeakPtr<ServiceWorkerContextCore> context,
                             ServiceWorkerDispatcherHost* dispatcher_host);
   virtual ~ServiceWorkerProviderHost();
 
@@ skipping 89 matching lines @@
   // Asks the renderer to send back the document information.
   void GetClientInfo(const GetClientInfoCallback& callback) const;
 
   // Adds reference of this host's process to the |pattern|, the reference will
   // be removed in destructor.
   void AddScopedProcessReferenceToPattern(const GURL& pattern);
 
   // |registration| claims the document to be controlled.
   void ClaimedByRegistration(ServiceWorkerRegistration* registration);
 
+  // Calls by dispatcher host to get "ready" registration.

[dominicc (has gone to gerrit), 2015/02/10 04:10:53]

Calls -> Called

"ready" registration -> the registration for the "ready" property

Would it make sense to link to the spec for ready?

[xiang, 2015/02/12 07:14:22]

Done.

+  void GetReadyRegistration(const GetReadyRegistrationCallback& callback);
+
   // Methods to support cross site navigations.
   void PrepareForCrossSiteTransfer();
   void CompleteCrossSiteTransfer(
       int new_process_id,
       int new_frame_id,
       int new_provider_id,
       ServiceWorkerDispatcherHost* dispatcher_host);
   ServiceWorkerDispatcherHost* dispatcher_host() const {
     return dispatcher_host_;
   }
 
   // Sends event messages to the renderer. Events for the worker are queued up
   // until the worker thread id is known via SetReadyToSendMessagesToWorker().
   void SendUpdateFoundMessage(
       const ServiceWorkerRegistrationObjectInfo& object_info);
   void SendSetVersionAttributesMessage(
       int registration_handle_id,
       ChangedVersionAttributesMask changed_mask,
       ServiceWorkerVersion* installing_version,
       ServiceWorkerVersion* waiting_version,
       ServiceWorkerVersion* active_version);
   void SendServiceWorkerStateChangedMessage(
       int worker_handle_id,
       blink::WebServiceWorkerState state);
 
   // Sets the worker thread id and flushes queued events.
   void SetReadyToSendMessagesToWorker(int render_thread_id);
 
+  // Potential registrations contain all registrations match this document URL.
+  void AddPotentialRegistration(ServiceWorkerRegistration* registration);
+  void RemovePotentialRegistration(ServiceWorkerRegistration* registration);
+  ServiceWorkerRegistration* GetMatchedRegistration() const;

[dominicc (has gone to gerrit), 2015/02/10 04:10:54]

I think it would be helpful to reference
https://slightlyoff.github.io/ServiceWorker/spec/service_worker/#scope-match-...
here, or on the implementation of the algorithm.

[xiang, 2015/02/12 07:14:22]

Done. It's an optimized impl of the algorithm for a document, use cases like
getRegistration() should still hit the DB.

+
  private:
   friend class ServiceWorkerProviderHostTest;
   friend class ServiceWorkerWriteToCacheJobTest;
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerContextRequestHandlerTest,
                            UpdateBefore24Hours);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerContextRequestHandlerTest,
                            UpdateAfter24Hours);
 
   // ServiceWorkerRegistration::Listener overrides.
+  void OnVersionAttributesChanged(
+      ServiceWorkerRegistration* registration,
+      ChangedVersionAttributesMask changed_mask,
+      const ServiceWorkerRegistrationInfo& info) override;
   void OnRegistrationFailed(ServiceWorkerRegistration* registration) override;
+  void OnRegistrationFinishedUninstalling(
+      ServiceWorkerRegistration* registration) override;
   void OnSkippedWaiting(ServiceWorkerRegistration* registration) override;
 
   // Sets the controller version field to |version| or if |version| is NULL,
   // clears the field.
   void SetControllerVersionAttribute(ServiceWorkerVersion* version);
 
   void SendAssociateRegistrationMessage();
 
   // Increase/decrease this host's process reference for |pattern|.
   void IncreaseProcessReference(const GURL& pattern);
   void DecreaseProcessReference(const GURL& pattern);
 
+  void ReturnReadyRegistrationIfNeeded();
+
   bool IsReadyToSendMessages() const;
   void Send(IPC::Message* message) const;
 
   int render_process_id_;
   int render_frame_id_;
   int render_thread_id_;
   int provider_id_;
   GURL document_url_;
   GURL topmost_frame_url_;
 
   std::vector<GURL> associated_patterns_;
   scoped_refptr<ServiceWorkerRegistration> associated_registration_;
 
+  // Keyed by registration scope URL length.
+  typedef std::map<size_t, scoped_refptr<ServiceWorkerRegistration>>
+      ServiceWorkerRegistrationMap;
+  // Contains associated registration and matched registartions created

[dominicc (has gone to gerrit), 2015/02/10 04:10:53]

Spelling: registrations

I think this is too confusing, we have

associated registrations
potential registrations
matched registrations
and ready registrations

I think you need to pick very distinct words and establish their separate
meaning with slightly more detailed comments.

If possible it would be good to align vocabulary with the spec (match,
matching). Instead of "ready registration" you could name things like
"registration for ready" perhaps.

[xiang, 2015/02/12 07:14:22]

Done, I tweaked these comments and names, please take another look.

+  // during the document's lifetime.
+  ServiceWorkerRegistrationMap potential_registrations_;
+
+  GetReadyRegistrationCallback registration_ready_callback_;
   scoped_refptr<ServiceWorkerVersion> controlling_version_;
   scoped_refptr<ServiceWorkerVersion> running_hosted_version_;
   base::WeakPtr<ServiceWorkerContextCore> context_;
   ServiceWorkerDispatcherHost* dispatcher_host_;
   bool allow_association_;
   bool is_claiming_;
 
   std::vector<base::Closure> queued_events_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerProviderHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_HOST_H_