ServiceWorker: Use scheduler's default task queue for posting tasks on main thread

content/renderer/service_worker/service_worker_script_context.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/renderer/service_worker/service_worker_script_context.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "content/child/notifications/notification_data_conversions.h"
@@ skipping 235 matching lines @@
 }
 
 void ServiceWorkerScriptContext::PostMessageToDocument(
     int client_id,
     const base::string16& message,
     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
   // This may send channels for MessagePorts, and all internal book-keeping
   // messages for MessagePort (e.g. QueueMessages) are sent from main thread
   // (with thread hopping), so we need to do the same thread hopping here not
   // to overtake those messages.
-  embedded_context_->main_thread_proxy()->PostTask(
+  embedded_context_->main_thread_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&SendPostMessageToDocumentOnMainThread,
                  make_scoped_refptr(embedded_context_->thread_safe_sender()),
                  GetRoutingID(), client_id, message, base::Passed(&channels)));
 }
 
 void ServiceWorkerScriptContext::PostCrossOriginMessageToClient(
     const blink::WebCrossOriginServiceWorkerClient& client,
     const base::string16& message,
     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
   // This may send channels for MessagePorts, and all internal book-keeping
   // messages for MessagePort (e.g. QueueMessages) are sent from main thread
   // (with thread hopping), so we need to do the same thread hopping here not
   // to overtake those messages.
-  embedded_context_->main_thread_proxy()->PostTask(
+  embedded_context_->main_thread_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&SendCrossOriginMessageToClientOnMainThread,
                  make_scoped_refptr(embedded_context_->thread_safe_sender()),
                  client.clientID, message, base::Passed(&channels)));
 }
 
 void ServiceWorkerScriptContext::FocusClient(
     int client_id, blink::WebServiceWorkerClientCallbacks* callback) {
   DCHECK(callback);
   int request_id = pending_client_callbacks_.Add(callback);
@@ skipping 123 matching lines @@
 }
 
 void ServiceWorkerScriptContext::OnPostMessage(
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids,
     const std::vector<int>& new_routing_ids) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnPostEvent");
   std::vector<WebMessagePortChannelImpl*> ports;
   if (!sent_message_port_ids.empty()) {
-    base::MessageLoopProxy* loop_proxy = embedded_context_->main_thread_proxy();
+    base::SingleThreadTaskRunner* task_runner =
+        embedded_context_->main_thread_task_runner();
     ports.resize(sent_message_port_ids.size());
     for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
       ports[i] = new WebMessagePortChannelImpl(
-          new_routing_ids[i], sent_message_port_ids[i], loop_proxy);
+          new_routing_ids[i], sent_message_port_ids[i], task_runner);
     }
   }
 
   // dispatchMessageEvent is expected to execute onmessage function
   // synchronously.
   base::TimeTicks before = base::TimeTicks::Now();
   proxy_->dispatchMessageEvent(message, ports);
   UMA_HISTOGRAM_TIMES(
       "ServiceWorker.MessageEventExecutionTime",
       base::TimeTicks::Now() - before);
 }
 
 void ServiceWorkerScriptContext::OnCrossOriginMessageToWorker(
     const NavigatorConnectClient& client,
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids,
     const std::vector<int>& new_routing_ids) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnCrossOriginMessageToWorker");
   std::vector<WebMessagePortChannelImpl*> ports;
   if (!sent_message_port_ids.empty()) {
-    base::MessageLoopProxy* loop_proxy = embedded_context_->main_thread_proxy();
+    base::SingleThreadTaskRunner* task_runner =
+        embedded_context_->main_thread_task_runner();
     ports.resize(sent_message_port_ids.size());
     for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
       ports[i] = new WebMessagePortChannelImpl(
-          new_routing_ids[i], sent_message_port_ids[i], loop_proxy);
+          new_routing_ids[i], sent_message_port_ids[i], task_runner);
     }
   }
 
   blink::WebCrossOriginServiceWorkerClient web_client;
   web_client.origin = client.origin;
   web_client.targetURL = client.target_url;
   web_client.clientID = client.message_port_id;
   proxy_->dispatchCrossOriginMessageEvent(web_client, message, ports);
 }
 
@@ skipping 125 matching lines @@
       new blink::WebServiceWorkerError(error_type, message));
   callbacks->onError(error.release());
   pending_claim_clients_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerScriptContext::OnPing() {
   Send(new ServiceWorkerHostMsg_Pong(GetRoutingID()));
 }
 
 }  // namespace content