ServiceWorker: Remove unused MessageEvent implementation from ServiceWorkerGlobalScope

content/browser/service_worker/service_worker_version.cc

 // 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.
 
 #include "content/browser/service_worker/service_worker_version.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 96 matching lines @@
     // We've tried to start the worker (and it has succeeded), but
     // it looks it's not running yet.
     NOTREACHED() << "The worker's not running after successful StartWorker";
     if (!error_callback.is_null())
       error_callback.Run(SERVICE_WORKER_ERROR_START_WORKER_FAILED);
     return;
   }
   task.Run();
 }
 
-void RunErrorMessageCallback(
-    const std::vector<TransferredMessagePort>& sent_message_ports,
-    const ServiceWorkerVersion::StatusCallback& callback,
-    ServiceWorkerStatusCode status) {
-  // Transfering the message ports failed, so destroy the ports.
-  for (const TransferredMessagePort& port : sent_message_ports) {
-    MessagePortService::GetInstance()->ClosePort(port.id);
-  }
-  callback.Run(status);
-}
-
 void KillEmbeddedWorkerProcess(int process_id, ResultCode code) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderProcessHost* render_process_host =
       RenderProcessHost::FromID(process_id);
   if (render_process_host->GetHandle() != base::kNullProcessHandle) {
     bad_message::ReceivedBadMessage(render_process_host,
                                     bad_message::SERVICE_WORKER_BAD_URL);
   }
 }
 
@@ skipping 416 matching lines @@
   if (running_status() == RUNNING) {
     DCHECK(start_callbacks_.empty());
     task.Run();
     return;
   }
   StartWorker(purpose,
               base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
                          error_callback, task));
 }
 
-void ServiceWorkerVersion::DispatchMessageEvent(
-    const base::string16& message,
-    const std::vector<TransferredMessagePort>& sent_message_ports,
-    const StatusCallback& callback) {
-  for (const TransferredMessagePort& port : sent_message_ports) {
-    MessagePortService::GetInstance()->HoldMessages(port.id);
-  }
-
-  DispatchMessageEventInternal(message, sent_message_ports, callback);
-}
-
-void ServiceWorkerVersion::DispatchMessageEventInternal(
-    const base::string16& message,
-    const std::vector<TransferredMessagePort>& sent_message_ports,
-    const StatusCallback& callback) {
-  OnBeginEvent();
-  if (running_status() != RUNNING) {
-    // Schedule calling this method after starting the worker.
-    StartWorker(ServiceWorkerMetrics::EventType::MESSAGE,
-                base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
-                           base::Bind(&RunErrorMessageCallback,
-                                      sent_message_ports, callback),
-                           base::Bind(&self::DispatchMessageEventInternal,
-                                      weak_factory_.GetWeakPtr(), message,
-                                      sent_message_ports, callback)));
-    return;
-  }
-
-  // TODO(kinuko): Cleanup this (and corresponding unit test) when message
-  // event becomes extendable, round-trip event. (crbug.com/498596)
-  RestartTick(&idle_time_);
-
-  MessagePortMessageFilter* filter =
-      embedded_worker_->message_port_message_filter();
-  std::vector<int> new_routing_ids;
-  filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
-  ServiceWorkerStatusCode status =
-      embedded_worker_->SendMessage(ServiceWorkerMsg_MessageToWorker(
-          message, sent_message_ports, new_routing_ids));
-  RunSoon(base::Bind(callback, status));
-}
-
 void ServiceWorkerVersion::AddControllee(
     ServiceWorkerProviderHost* provider_host) {
   const std::string& uuid = provider_host->client_uuid();
   CHECK(!provider_host->client_uuid().empty());
   DCHECK(!ContainsKey(controllee_map_, uuid));
   controllee_map_[uuid] = provider_host;
   // Keep the worker alive a bit longer right after a new controllee is added.
   RestartTick(&idle_time_);
   FOR_EACH_OBSERVER(Listener, listeners_,
                     OnControlleeAdded(this, provider_host));
@@ skipping 1114 matching lines @@
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ || running_status() != RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 }  // namespace content