Revise ServiceWorker DevTools protocols.

content/browser/devtools/protocol/service_worker_handler.cc

 // Copyright 2015 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/devtools/protocol/service_worker_handler.h"
 
 #include "base/bind.h"
+#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/browser/service_worker/service_worker_version.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "url/gurl.h"
 
 // Windows headers will redefine SendMessage.
 #ifdef SendMessage
@@ skipping 53 matching lines @@
           ->set_status(GetVersionStatusString(version_info.status)));
   return version;
 }
 
 scoped_refptr<ServiceWorkerRegistration> CreateRegistrationDictionaryValue(
     const ServiceWorkerRegistrationInfo& registration_info) {
   scoped_refptr<ServiceWorkerRegistration> registration(
       ServiceWorkerRegistration::Create()
           ->set_registration_id(
                 base::Int64ToString(registration_info.registration_id))
-          ->set_scope_url(registration_info.pattern.spec()));
-  if (registration_info.active_version.version_id !=
-      kInvalidServiceWorkerVersionId) {
-    registration->set_active_version(
-        CreateVersionDictionaryValue(registration_info.active_version));
-  }
-  if (registration_info.waiting_version.version_id !=
-      kInvalidServiceWorkerVersionId) {
-    registration->set_waiting_version(
-        CreateVersionDictionaryValue(registration_info.waiting_version));
-  }
-  if (registration_info.installing_version.version_id !=
-      kInvalidServiceWorkerVersionId) {
-    registration->set_installing_version(
-        CreateVersionDictionaryValue(registration_info.installing_version));
-  }
+          ->set_scope_url(registration_info.pattern.spec())
+          ->set_is_deleted(registration_info.is_deleted));
   return registration;
 }
 
+bool IsStoppedAndRedundant(const ServiceWorkerVersionInfo& version_info) {
+  return version_info.running_status ==
+             content::ServiceWorkerVersion::STOPPED &&
+         version_info.status == content::ServiceWorkerVersion::REDUNDANT;
+}
+
 }  // namespace
 
 using Response = DevToolsProtocolClient::Response;
 
 class ServiceWorkerHandler::ContextObserver

[pfeldman, 2015/03/12 12:23:23]

Is this time to kick it out of the class? Seems like it is growing fast.

[horo, 2015/03/12 13:54:14]

Done.

     : public ServiceWorkerContextObserver,
       public base::RefCountedThreadSafe<ContextObserver> {
  public:
   ContextObserver(scoped_refptr<ServiceWorkerContextWrapper> context,
                   base::WeakPtr<ServiceWorkerHandler> handler);
   void Start();
   void Stop();
 
  private:
   friend class base::RefCountedThreadSafe<ContextObserver>;
   ~ContextObserver() override;
   void GetStoredRegistrationsOnIOThread();
   void OnStoredRegistrationsOnIOThread(
-      const std::vector<ServiceWorkerRegistrationInfo>& registrations);
+      const std::vector<ServiceWorkerRegistrationInfo>& stored_registrations);
   void StopOnIOThread();
 
-  void OnVersionUpdated(int64 version_id);
-  void OnRegistrationUpdated(int64 registration_id);
+  void StoreRegistrationInfo(
+      const ServiceWorkerRegistrationInfo& registration,
+      base::ScopedPtrHashMap<int64, ServiceWorkerRegistrationInfo>* info_map);
+  void StoreVersionInfo(const ServiceWorkerVersionInfo& version);
+
+  void SendRegistrationInfo(int64 registration_id,
+                            const GURL& pattern,
+                            bool is_deleted);
+  void SendVersionInfo(const ServiceWorkerVersionInfo& version);
 
   // ServiceWorkerContextObserver implements
-  void OnRunningStateChanged(int64 version_id) override;
-  void OnVersionStateChanged(int64 version_id) override;
+  virtual void OnNewLiveRegistration(int64 registration_id,
+                                     const GURL& pattern) override;
+  virtual void OnNewLiveVersion(int64 version_id,
+                                int64 registration_id,
+                                const GURL& script_url) override;
+  void OnRunningStateChanged(
+      int64 version_id,
+      content::ServiceWorkerVersion::RunningStatus running_status) override;
+  void OnVersionStateChanged(
+      int64 version_id,
+      content::ServiceWorkerVersion::Status status) override;
   void OnRegistrationStored(int64 registration_id,
                             const GURL& pattern) override;
   void OnRegistrationDeleted(int64 registration_id,
                              const GURL& pattern) override;
 
+  base::ScopedPtrHashMap<int64, ServiceWorkerVersionInfo> version_info_map_;
   scoped_refptr<ServiceWorkerContextWrapper> context_;
   base::WeakPtr<ServiceWorkerHandler> handler_;
 };
 
 ServiceWorkerHandler::ContextObserver::ContextObserver(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     base::WeakPtr<ServiceWorkerHandler> handler)
     : context_(context), handler_(handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
@@ skipping 14 matching lines @@
 }
 
 void ServiceWorkerHandler::ContextObserver::GetStoredRegistrationsOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context_->context()->storage()->GetAllRegistrations(base::Bind(
       &ServiceWorkerHandler::ContextObserver::OnStoredRegistrationsOnIOThread,
       this));
 }
 
 void ServiceWorkerHandler::ContextObserver::OnStoredRegistrationsOnIOThread(
-    const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
+    const std::vector<ServiceWorkerRegistrationInfo>& stored_registrations) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context_->AddObserver(this);
+
+  base::ScopedPtrHashMap<int64, ServiceWorkerRegistrationInfo>
+      registration_info_map;
+  for (const auto& registration : stored_registrations)
+    StoreRegistrationInfo(registration, &registration_info_map);
+  for (const auto& registration :
+       context_->context()->GetAllLiveRegistrationInfo()) {
+    StoreRegistrationInfo(registration, &registration_info_map);
+  }
+  for (const auto& version : context_->context()->GetAllLiveVersionInfo())
+    StoreVersionInfo(version);
+
+  std::vector<ServiceWorkerRegistrationInfo> registrations;
+  registrations.reserve(registration_info_map.size());
+  for (const auto& registration_id_info_pair : registration_info_map)
+    registrations.push_back(*registration_id_info_pair.second);
+
+  std::vector<ServiceWorkerVersionInfo> versions;
+  versions.reserve(version_info_map_.size());
+
+  for (auto version_it = version_info_map_.begin();
+       version_it != version_info_map_.end();) {
+    versions.push_back(*version_it->second);
+    if (IsStoppedAndRedundant(*version_it->second))
+      version_info_map_.erase(version_it++);
+    else
+      ++version_it;
+  }
+
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated, handler_,
                  registrations));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated, handler_,
-                 context_->context()->GetAllLiveRegistrationInfo()));
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerVersionUpdated, handler_,
-                 context_->context()->GetAllLiveVersionInfo()));
+                 versions));
 }
 
 void ServiceWorkerHandler::ContextObserver::StopOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context_->RemoveObserver(this);
 }
 
 ServiceWorkerHandler::ContextObserver::~ContextObserver() {
 }
 
-void ServiceWorkerHandler::ContextObserver::OnVersionUpdated(int64 version_id) {
+void ServiceWorkerHandler::ContextObserver::StoreRegistrationInfo(
+    const ServiceWorkerRegistrationInfo& registration_info,
+    base::ScopedPtrHashMap<int64, ServiceWorkerRegistrationInfo>* info_map) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  content::ServiceWorkerVersion* version =
-      context_->context()->GetLiveVersion(version_id);
-  if (!version)
+  if (registration_info.registration_id == kInvalidServiceWorkerRegistrationId)
     return;
-  OnRegistrationUpdated(version->registration_id());
+  info_map->set(registration_info.registration_id,
+                scoped_ptr<ServiceWorkerRegistrationInfo>(
+                    new ServiceWorkerRegistrationInfo(registration_info)));
+  StoreVersionInfo(registration_info.active_version);
+  StoreVersionInfo(registration_info.waiting_version);
+  StoreVersionInfo(registration_info.installing_version);
+}
+
+void ServiceWorkerHandler::ContextObserver::StoreVersionInfo(
+    const ServiceWorkerVersionInfo& version_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (version_info.version_id == kInvalidServiceWorkerVersionId)
+    return;
+  version_info_map_.set(version_info.version_id,
+                        scoped_ptr<ServiceWorkerVersionInfo>(
+                            new ServiceWorkerVersionInfo(version_info)));
+}
+
+void ServiceWorkerHandler::ContextObserver::SendRegistrationInfo(
+    int64 registration_id,
+    const GURL& pattern,
+    bool is_deleted) {
+  std::vector<ServiceWorkerRegistrationInfo> registrations;
+  registrations.push_back(
+      ServiceWorkerRegistrationInfo(pattern, registration_id, is_deleted));
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated, handler_,
+                 registrations));
+}
+
+void ServiceWorkerHandler::ContextObserver::SendVersionInfo(
+    const ServiceWorkerVersionInfo& version_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   std::vector<ServiceWorkerVersionInfo> versions;
-  versions.push_back(version->GetInfo());
+  versions.push_back(version_info);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ServiceWorkerHandler::OnWorkerVersionUpdated, handler_,
                  versions));
 }
 
-void ServiceWorkerHandler::ContextObserver::OnRegistrationUpdated(
-    int64 registration_id) {
-  content::ServiceWorkerRegistration* registration =
-      context_->context()->GetLiveRegistration(registration_id);
-  if (!registration)
+void ServiceWorkerHandler::ContextObserver::OnNewLiveRegistration(
+    int64 registration_id,
+    const GURL& pattern) {
+  SendRegistrationInfo(registration_id, pattern, false);
+}
+
+void ServiceWorkerHandler::ContextObserver::OnNewLiveVersion(
+    int64 version_id,
+    int64 registration_id,
+    const GURL& script_url) {
+  if (ServiceWorkerVersionInfo* version = version_info_map_.get(version_id)) {
+    DCHECK(version->registration_id == registration_id);
+    DCHECK(version->script_url == script_url);
     return;
-  std::vector<ServiceWorkerRegistrationInfo> registrations;
-  registrations.push_back(registration->GetInfo());
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated, handler_,
-                 registrations));
+  }
+
+  scoped_ptr<ServiceWorkerVersionInfo> version(new ServiceWorkerVersionInfo());
+  version->version_id = version_id;
+  version->registration_id = registration_id;
+  version->script_url = script_url;
+  SendVersionInfo(*version);
+  if (!IsStoppedAndRedundant(*version))
+    version_info_map_.set(version_id, version.Pass());
 }
 
 void ServiceWorkerHandler::ContextObserver::OnRunningStateChanged(
-    int64 version_id) {
-  OnVersionUpdated(version_id);
+    int64 version_id,
+    content::ServiceWorkerVersion::RunningStatus running_status) {
+  ServiceWorkerVersionInfo* version = version_info_map_.get(version_id);
+  DCHECK(version);
+  if (version->running_status == running_status)
+    return;
+  version->running_status = running_status;
+  SendVersionInfo(*version);
+  if (IsStoppedAndRedundant(*version))
+    version_info_map_.erase(version_id);
 }
 
 void ServiceWorkerHandler::ContextObserver::OnVersionStateChanged(
-    int64 version_id) {
-  OnVersionUpdated(version_id);
+    int64 version_id,
+    content::ServiceWorkerVersion::Status status) {
+  ServiceWorkerVersionInfo* version = version_info_map_.get(version_id);
+  DCHECK(version);
+  if (version->status == status)
+    return;
+  version->status = status;
+  SendVersionInfo(*version);
+  if (IsStoppedAndRedundant(*version))
+    version_info_map_.erase(version_id);
 }
 
 void ServiceWorkerHandler::ContextObserver::OnRegistrationStored(
     int64 registration_id,
     const GURL& pattern) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  content::ServiceWorkerRegistration* registration =
-      context_->context()->GetLiveRegistration(registration_id);
-  DCHECK(registration);
-  std::vector<ServiceWorkerRegistrationInfo> registrations;
-  registrations.push_back(registration->GetInfo());
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated, handler_,
-                 registrations));
+  SendRegistrationInfo(registration_id, pattern, false);
 }
 
 void ServiceWorkerHandler::ContextObserver::OnRegistrationDeleted(
     int64 registration_id,
     const GURL& pattern) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationDeleted, handler_,
-                 registration_id));
+  SendRegistrationInfo(registration_id, pattern, true);
 }
 
 ServiceWorkerHandler::ServiceWorkerHandler()
     : enabled_(false), weak_factory_(this) {
 }
 
 ServiceWorkerHandler::~ServiceWorkerHandler() {
   Disable();
 }
 
@@ skipping 111 matching lines @@
 void ServiceWorkerHandler::OnWorkerVersionUpdated(
     const std::vector<ServiceWorkerVersionInfo>& versions) {
   std::vector<scoped_refptr<ServiceWorkerVersion>> version_values;
   for (const auto& version : versions) {
     version_values.push_back(CreateVersionDictionaryValue(version));
   }
   client_->WorkerVersionUpdated(
       WorkerVersionUpdatedParams::Create()->set_versions(version_values));
 }
 
-void ServiceWorkerHandler::OnWorkerRegistrationDeleted(int64 registration_id) {
-  client_->WorkerRegistrationDeleted(
-      WorkerRegistrationDeletedParams::Create()->set_registration_id(
-          base::Int64ToString(registration_id)));
-}
-
 void ServiceWorkerHandler::DispatchProtocolMessage(
     DevToolsAgentHost* host,
     const std::string& message) {
 
   auto it = attached_hosts_.find(host->GetId());
   if (it == attached_hosts_.end())
     return;  // Already disconnected.
 
   client_->DispatchMessage(
       DispatchMessageParams::Create()->
@@ skipping 40 matching lines @@
 bool ServiceWorkerHandler::MatchesInspectedPage(
     ServiceWorkerDevToolsAgentHost* host) {
   // TODO(pfeldman): match based on scope.
   // TODO(pfeldman): match iframes.
   return host->GetURL().host() == url_.host();
 }
 
 }  // namespace service_worker
 }  // namespace devtools
 }  // namespace content