Send WorkerHostMsg_WorkerConnected in EmbeddedSharedWorkerStub::OnConnect.

content/renderer/shared_worker/embedded_shared_worker_stub.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/shared_worker/embedded_shared_worker_stub.h"
 
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/child/scoped_child_process_reference.h"
 #include "content/child/shared_worker_devtools_agent.h"
 #include "content/child/webmessageportchannel_impl.h"
@@ skipping 45 matching lines @@
   OnTerminateWorkerContext();
 }
 
 void EmbeddedSharedWorkerStub::workerScriptLoaded() {
   Send(new WorkerHostMsg_WorkerScriptLoaded(route_id_));
   runing_ = true;
   // Process any pending connections.
   for (PendingChannelList::const_iterator iter = pending_channels_.begin();
        iter != pending_channels_.end();
        ++iter) {
-    impl_->connect(*iter);
-    Send(new WorkerHostMsg_WorkerConnected((*iter)->message_port_id(),
-                                           route_id_));
+    ConnectToChannel(*iter);
   }
   pending_channels_.clear();
 }
 
 void EmbeddedSharedWorkerStub::workerScriptLoadFailed() {
   Send(new WorkerHostMsg_WorkerScriptLoadFailed(route_id_));
   for (PendingChannelList::const_iterator iter = pending_channels_.begin();
        iter != pending_channels_.end();
        ++iter) {
     blink::WebMessagePortChannel* channel = *iter;
@@ skipping 48 matching lines @@
 }
 
 void EmbeddedSharedWorkerStub::Shutdown() {
   delete this;
 }
 
 bool EmbeddedSharedWorkerStub::Send(IPC::Message* message) {
   return RenderThreadImpl::current()->Send(message);
 }
 
+void EmbeddedSharedWorkerStub::ConnectToChannel(
+    WebMessagePortChannelImpl* channel) {
+  impl_->connect(channel);
+  Send(
+      new WorkerHostMsg_WorkerConnected(channel->message_port_id(), route_id_));
+}
+
 void EmbeddedSharedWorkerStub::OnConnect(int sent_message_port_id,
                                          int routing_id) {
   WebMessagePortChannelImpl* channel =
       new WebMessagePortChannelImpl(routing_id,
                                     sent_message_port_id,
                                     base::MessageLoopProxy::current().get());
   if (runing_) {
-    impl_->connect(channel);
+    ConnectToChannel(channel);
   } else {
     // If two documents try to load a SharedWorker at the same time, the
     // WorkerMsg_Connect for one of the documents can come in before the
     // worker is started. Just queue up the connect and deliver it once the
     // worker starts.
     pending_channels_.push_back(channel);
   }
 }
 
 void EmbeddedSharedWorkerStub::OnTerminateWorkerContext() {
   runing_ = false;
   impl_->terminateWorkerContext();
 }
 
 }  // namespace content