Push API: fire push event from chrome://serviceworker-internals/

content/browser/service_worker/service_worker_internals_ui.cc

 // Copyright 2014 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/service_worker/service_worker_internals_ui.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 39 matching lines @@
                                   const base::FilePath& context_path);
   void UnregisterOnIOThread(scoped_refptr<ServiceWorkerContextWrapper> context,
                             const GURL& scope);
   void StartWorkerOnIOThread(scoped_refptr<ServiceWorkerContextWrapper> context,
                              const GURL& scope);
   void StopWorkerOnIOThread(scoped_refptr<ServiceWorkerContextWrapper> context,
                             const GURL& scope);
   void DispatchSyncEventToWorkerOnIOThread(
       scoped_refptr<ServiceWorkerContextWrapper> context,
       const GURL& scope);
+  void DispatchPushEventToWorkerOnIOThread(
+      scoped_refptr<ServiceWorkerContextWrapper> context,
+      const GURL& scope);
   void InspectWorkerOnIOThread(
       scoped_refptr<ServiceWorkerContextWrapper> context,
       const GURL& scope);
 
  private:
   friend class base::RefCountedThreadSafe<OperationProxy>;
   ~OperationProxy() {}
   void OnHaveRegistrations(
       int partition_id,
       const base::FilePath& context_path,
       const std::vector<ServiceWorkerRegistrationInfo>& registrations);
 
   void OperationComplete(ServiceWorkerStatusCode status);
 
   void StartActiveWorker(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
   void StopActiveWorker(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
   void DispatchSyncEventToActiveWorker(
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
+  void DispatchPushEventToActiveWorker(
+      ServiceWorkerStatusCode status,
+      const scoped_refptr<ServiceWorkerRegistration>& registration);
+
   void InspectActiveWorker(
       const ServiceWorkerContextCore* const service_worker_context,
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& registration);
 
   void InspectWorkerOnUIThread(
       const ServiceWorkerContextCore* const service_worker_context,
       int64 version_id);
 
   WeakPtr<ServiceWorkerInternalsUI> internals_;
@@ skipping 121 matching lines @@
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "unregister",
       base::Bind(&ServiceWorkerInternalsUI::Unregister,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "sync",
       base::Bind(&ServiceWorkerInternalsUI::DispatchSyncEventToWorker,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
+      "push",
+      base::Bind(&ServiceWorkerInternalsUI::DispatchPushEventToWorker,
+                 base::Unretained(this)));
+  web_ui->RegisterMessageCallback(
       "inspect",
       base::Bind(&ServiceWorkerInternalsUI::InspectWorker,
                  base::Unretained(this)));
 }
 
 ServiceWorkerInternalsUI::~ServiceWorkerInternalsUI() {
   BrowserContext* browser_context =
       web_ui()->GetWebContents()->GetBrowserContext();
   // Safe to use base::Unretained(this) because
   // ForEachStoragePartition is synchronous.
@@ skipping 111 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ServiceWorkerInternalsUI::OperationProxy::
                      DispatchSyncEventToWorkerOnIOThread,
                  new OperationProxy(AsWeakPtr(), args_copy.Pass()),
                  context,
                  scope));
 }
 
+void ServiceWorkerInternalsUI::DispatchPushEventToWorker(
+    const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  base::FilePath partition_path;
+  GURL scope;
+  scoped_refptr<ServiceWorkerContextWrapper> context;
+  if (!GetRegistrationInfo(args, &partition_path, &scope, &context))
+    return;
+
+  scoped_ptr<ListValue> args_copy(args->DeepCopy());
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ServiceWorkerInternalsUI::OperationProxy::
+                     DispatchPushEventToWorkerOnIOThread,
+                 new OperationProxy(AsWeakPtr(), args_copy.Pass()),
+                 context,
+                 scope));
+}
+
 void ServiceWorkerInternalsUI::InspectWorker(const ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::FilePath partition_path;
   GURL scope;
   scoped_refptr<ServiceWorkerContextWrapper> context;
   if (!GetRegistrationInfo(args, &partition_path, &scope, &context))
     return;
   scoped_ptr<ListValue> args_copy(args->DeepCopy());
   BrowserThread::PostTask(
       BrowserThread::IO,
@@ skipping 114 matching lines @@
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GURL& scope) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context->context()->storage()->FindRegistrationForPattern(
       scope,
       base::Bind(&ServiceWorkerInternalsUI::OperationProxy::
                      DispatchSyncEventToActiveWorker,
                  this));
 }
 
+void
+ServiceWorkerInternalsUI::OperationProxy::DispatchPushEventToWorkerOnIOThread(
+    scoped_refptr<ServiceWorkerContextWrapper> context,
+    const GURL& scope) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  context->context()->storage()->FindRegistrationForPattern(
+      scope,
+      base::Bind(&ServiceWorkerInternalsUI::OperationProxy::
+                     DispatchPushEventToActiveWorker,
+                 this));
+}
+
 void ServiceWorkerInternalsUI::OperationProxy::InspectWorkerOnIOThread(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GURL& scope) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context->context()->storage()->FindRegistrationForPattern(
       scope,
       base::Bind(&ServiceWorkerInternalsUI::OperationProxy::InspectActiveWorker,
                  this,
                  context->context()));
 }
@@ skipping 148 matching lines @@
       registration->active_version()->status() ==
           ServiceWorkerVersion::ACTIVE) {
     registration->active_version()->DispatchSyncEvent(base::Bind(
         &ServiceWorkerInternalsUI::OperationProxy::OperationComplete, this));
     return;
   }
 
   OperationComplete(SERVICE_WORKER_ERROR_FAILED);
 }
 
+void ServiceWorkerInternalsUI::OperationProxy::DispatchPushEventToActiveWorker(
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (status == SERVICE_WORKER_OK && registration->active_version() &&
+      registration->active_version()->status() ==
+          ServiceWorkerVersion::ACTIVE) {
+    registration->active_version()->DispatchPushEvent(base::Bind(
+        &ServiceWorkerInternalsUI::OperationProxy::OperationComplete, this));
+    return;
+  }
+
+  OperationComplete(SERVICE_WORKER_ERROR_FAILED);
+}
+
 void ServiceWorkerInternalsUI::OperationProxy::InspectActiveWorker(
     const ServiceWorkerContextCore* const service_worker_context,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (status == SERVICE_WORKER_OK) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&OperationProxy::InspectWorkerOnUIThread,
@@ skipping 19 matching lines @@
     DevToolsManagerImpl::GetInstance()->Inspect(
         internals_->web_ui()->GetWebContents()->GetBrowserContext(),
         agent_host.get());
     OperationComplete(SERVICE_WORKER_OK);
     return;
   }
   OperationComplete(SERVICE_WORKER_ERROR_NOT_FOUND);
 }
 
 }  // namespace content