(SUSPENDED) SharedWorker: Mojofy Renderer(Document)->Browser communication for SharedWorker

content/browser/shared_worker/shared_worker_service_impl_unittest.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/shared_worker/shared_worker_service_impl.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 15 matching lines @@
 #include "content/common/worker_messages.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "ipc/ipc_sync_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
+namespace {
+
+void CreateWorkerCallback(int* route_id_out,
+                          blink::WebWorkerCreationError* creation_error_out,
+                          int route_id,
+                          blink::WebWorkerCreationError creation_error) {
+  *route_id_out = route_id;
+  *creation_error_out = creation_error;
+}
+
+}  // namespace
+
 class SharedWorkerServiceImplTest : public testing::Test {
  public:
   static void RegisterRunningProcessID(int process_id) {
     base::AutoLock lock(s_lock_);
     s_running_process_id_set_.insert(process_id);
   }
   static void UnregisterRunningProcessID(int process_id) {
     base::AutoLock lock(s_lock_);
     s_running_process_id_set_.erase(process_id);
   }
@@ skipping 158 matching lines @@
       queued_messages_.pop_back();
       IPC::SyncMessage* sync_msg = static_cast<IPC::SyncMessage*>(message);
       std::unique_ptr<IPC::MessageReplyDeserializer> reply_serializer(
           sync_msg->GetReplyDeserializer());
       bool result = reply_serializer->SerializeOutputParameters(*response_msg);
       CHECK(result);
     }
     return ret;
   }
 
+  // Emulates mojo RPC calls (Renderer(Document)->Browser).
+  void OnCreateWorker(mojom::SharedWorker_CreateWorker_ParamsPtr params,
+                      int* route_id_out,
+                      blink::WebWorkerCreationError* creation_error_out) {
+    worker_filter_->OnCreateWorker(
+        std::move(params),
+        base::Bind(&CreateWorkerCallback, route_id_out, creation_error_out));
+  }
+
+  void OnConnectToWorker(int route_id, int message_port_id) {
+    worker_filter_->OnConnectToWorker(route_id, message_port_id);
+  }
+
   size_t QueuedMessageCount() const { return queued_messages_.size(); }
 
   std::unique_ptr<IPC::Message> PopMessage() {
     CHECK(queued_messages_.size());
     std::unique_ptr<IPC::Message> msg(queued_messages_.begin()->release());
     queued_messages_.erase(queued_messages_.begin());
     return msg;
   }
 
   void FastShutdownIfPossible() {
@@ skipping 21 matching lines @@
       new MessagePortHostMsg_Entangle(*port_1, *port_2)));
   EXPECT_TRUE(renderer->OnMessageReceived(
       new MessagePortHostMsg_Entangle(*port_2, *port_1)));
 }
 
 void PostCreateWorker(MockRendererProcessHost* renderer,
                       const std::string& url,
                       const std::string& name,
                       unsigned long long document_id,
                       int render_frame_route_id,
-                      ViewHostMsg_CreateWorker_Reply* reply) {
-  ViewHostMsg_CreateWorker_Params params;
-  params.url = GURL(url);
-  params.name = base::ASCIIToUTF16(name);
-  params.content_security_policy = base::string16();
-  params.security_policy_type = blink::WebContentSecurityPolicyTypeReport;
-  params.document_id = document_id;
-  params.render_frame_route_id = render_frame_route_id;
-  params.creation_context_type =
+                      int* route_id_out,
+                      blink::WebWorkerCreationError* creation_error_out) {
+  mojom::SharedWorker_CreateWorker_ParamsPtr params =
+      mojom::SharedWorker_CreateWorker_Params::New();
+  params->url = GURL(url);
+  params->name = base::ASCIIToUTF16(name);
+  params->content_security_policy = base::string16();
+  params->security_policy_type = blink::WebContentSecurityPolicyTypeReport;
+  params->document_id = document_id;
+  params->render_frame_route_id = render_frame_route_id;
+  params->creation_context_type =
       blink::WebSharedWorkerCreationContextTypeSecure;
-  EXPECT_TRUE(
-      renderer->OnMessageReceived(new ViewHostMsg_CreateWorker(params, reply)));
+  renderer->OnCreateWorker(std::move(params), route_id_out, creation_error_out);
 }
 
 class MockSharedWorkerConnector {
  public:
   MockSharedWorkerConnector(MockRendererProcessHost* renderer_host)
       : renderer_host_(renderer_host),
         temporary_remote_port_route_id_(0),
         remote_port_id_(0),
         local_port_route_id_(0),
         local_port_id_(0) {}
   void Create(const std::string& url,
               const std::string& name,
               unsigned long long document_id,
               int render_frame_route_id) {
     CreateMessagePortPair(renderer_host_,
                           &temporary_remote_port_route_id_,
                           &remote_port_id_,
                           &local_port_route_id_,
                           &local_port_id_);
     PostCreateWorker(renderer_host_, url, name, document_id,
-                     render_frame_route_id, &create_worker_reply_);
+                     render_frame_route_id, &route_id_, &creation_error_);
   }
   void SendQueueMessages() {
     EXPECT_TRUE(renderer_host_->OnMessageReceived(
         new MessagePortHostMsg_QueueMessages(remote_port_id_)));
   }
   void SendPostMessage(const std::string& data) {
     const std::vector<int> empty_ports;
     EXPECT_TRUE(
         renderer_host_->OnMessageReceived(new MessagePortHostMsg_PostMessage(
             local_port_id_, base::ASCIIToUTF16(data), empty_ports)));
   }
   void SendConnect() {
-    EXPECT_TRUE(
-        renderer_host_->OnMessageReceived(new ViewHostMsg_ConnectToWorker(
-            create_worker_reply_.route_id, remote_port_id_)));
+    renderer_host_->OnConnectToWorker(route_id_, remote_port_id_);
   }
   void SendSendQueuedMessages(
       const std::vector<QueuedMessage>& queued_messages) {
     EXPECT_TRUE(renderer_host_->OnMessageReceived(
         new MessagePortHostMsg_SendQueuedMessages(remote_port_id_,
                                                   queued_messages)));
   }
   int temporary_remote_port_route_id() {
     return temporary_remote_port_route_id_;
   }
   int remote_port_id() { return remote_port_id_; }
   int local_port_route_id() { return local_port_route_id_; }
   int local_port_id() { return local_port_id_; }
-  int route_id() { return create_worker_reply_.route_id; }
-  blink::WebWorkerCreationError creation_error() {
-    return create_worker_reply_.error;
-  }
+  int route_id() { return route_id_; }
+  blink::WebWorkerCreationError creation_error() { return creation_error_; }
 
  private:
   MockRendererProcessHost* renderer_host_;
   int temporary_remote_port_route_id_;
   int remote_port_id_;
   int local_port_route_id_;
   int local_port_id_;
-  ViewHostMsg_CreateWorker_Reply create_worker_reply_;
+  int route_id_;
+  blink::WebWorkerCreationError creation_error_;
 };
 
 void CheckWorkerProcessMsgCreateWorker(
     MockRendererProcessHost* renderer_host,
     const std::string& expected_url,
     const std::string& expected_name,
     blink::WebContentSecurityPolicyType expected_security_policy_type,
     int* route_id) {
   std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type());
@@ skipping 639 matching lines @@
                      kDocumentIDs[2],
                      kRenderFrameRouteIDs[2]);
   EXPECT_NE(MSG_ROUTING_NONE, connector2->route_id());
   EXPECT_EQ(0U, renderer_host2->QueuedMessageCount());
   RunAllPendingInMessageLoop();
   EXPECT_EQ(1U, renderer_host2->QueuedMessageCount());
   CheckViewMsgWorkerCreated(renderer_host2.get(), connector2.get());
 }
 
 }  // namespace content