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 64 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   scoped_refptr<ServiceWorkerVersion> version =
       context->context()->GetLiveVersion(version_id);
   if (!version) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
   (*version.*method)(callback);
 }
 
+void DispatchPushEventWithVersionID(
+    scoped_refptr<ServiceWorkerContextWrapper> context,
+    int64 version_id,
+    const ServiceWorkerInternalsUI::StatusCallback& callback) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(DispatchPushEventWithVersionID,
+                   context,
+                   version_id,
+                   callback));
+    return;
+  }
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  scoped_refptr<ServiceWorkerVersion> version =
+      context->context()->GetLiveVersion(version_id);
+  if (!version) {
+    callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
+    return;
+  }
+  std::string data = "Test push message from ServiceWorkerInternals.";
+  version->DispatchPushEvent(callback, data);
+}
+
 void UnregisterWithScope(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GURL& scope,
     const ServiceWorkerInternalsUI::StatusCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(UnregisterWithScope, context, scope, callback));
     return;
@@ skipping 298 matching lines @@
       "stop",
       base::Bind(&ServiceWorkerInternalsUI::CallServiceWorkerVersionMethod,
                  base::Unretained(this),
                  &ServiceWorkerVersion::StopWorker));
   web_ui->RegisterMessageCallback(
       "sync",
       base::Bind(&ServiceWorkerInternalsUI::CallServiceWorkerVersionMethod,
                  base::Unretained(this),
                  &ServiceWorkerVersion::DispatchSyncEvent));
   web_ui->RegisterMessageCallback(
+      "push",
+      base::Bind(&ServiceWorkerInternalsUI::DispatchPushEvent,
+                 base::Unretained(this)));
+  web_ui->RegisterMessageCallback(
       "inspect",
       base::Bind(&ServiceWorkerInternalsUI::InspectWorker,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "unregister",
       base::Bind(&ServiceWorkerInternalsUI::Unregister,
                  base::Unretained(this)));
   web_ui->RegisterMessageCallback(
       "start",
       base::Bind(&ServiceWorkerInternalsUI::StartWorker,
@@ skipping 131 matching lines @@
       !base::StringToInt64(version_id_string, &version_id)) {
     return;
   }
 
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   CallServiceWorkerVersionMethodWithVersionID(
       method, context, version_id, callback);
 }
 
+void ServiceWorkerInternalsUI::DispatchPushEvent(
+    const ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  int callback_id;
+  int partition_id;
+  int64 version_id;
+  std::string version_id_string;
+  const DictionaryValue* cmd_args = NULL;
+  scoped_refptr<ServiceWorkerContextWrapper> context;
+  if (!args->GetInteger(0, &callback_id) ||
+      !args->GetDictionary(1, &cmd_args) ||
+      !cmd_args->GetInteger("partition_id", &partition_id) ||
+      !GetServiceWorkerContext(partition_id, &context) ||
+      !cmd_args->GetString("version_id", &version_id_string) ||
+      !base::StringToInt64(version_id_string, &version_id)) {
+    return;
+  }
+
+  base::Callback<void(ServiceWorkerStatusCode)> callback =
+      base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
+  DispatchPushEventWithVersionID(context, version_id, callback);
+}
+
 void ServiceWorkerInternalsUI::InspectWorker(const ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   int callback_id;
   int process_id;
   int devtools_agent_route_id;
   const DictionaryValue* cmd_args = NULL;
   scoped_refptr<ServiceWorkerContextWrapper> context;
   if (!args->GetInteger(0, &callback_id) ||
       !args->GetDictionary(1, &cmd_args) ||
       !cmd_args->GetInteger("process_id", &process_id) ||
@@ skipping 50 matching lines @@
     return;
   }
 
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   FindRegistrationForPattern(
       context, GURL(scope_string), base::Bind(StartActiveWorker, callback));
 }
 
 }  // namespace content