Optionally have MessagePort pass data as base::Value, part 1.

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 <map>
 #include <set>
 #include <vector>
 
 #include "base/atomic_sequence_num.h"
 #include "base/basictypes.h"
@@ skipping 270 matching lines @@
                      &route_id_);
   }
   void SendQueueMessages() {
     EXPECT_TRUE(renderer_host_->OnMessageReceived(
         new MessagePortHostMsg_QueueMessages(remote_port_id_)));
   }
   void SendPostMessage(std::string data) {
     const std::vector<int> empty_ids;
     EXPECT_TRUE(
         renderer_host_->OnMessageReceived(new MessagePortHostMsg_PostMessage(
-            local_port_id_, base::ASCIIToUTF16(data), empty_ids)));
+            local_port_id_,
+            MessagePortMessage(base::ASCIIToUTF16(data)), empty_ids)));
   }
   void SendConnect() {
     EXPECT_TRUE(
         renderer_host_->OnMessageReceived(new ViewHostMsg_ForwardToWorker(
             WorkerMsg_Connect(route_id_, remote_port_id_, MSG_ROUTING_NONE))));
   }
   void SendSendQueuedMessages(
       const std::vector<QueuedMessage>& queued_messages) {
     EXPECT_TRUE(renderer_host_->OnMessageReceived(
         new MessagePortHostMsg_SendQueuedMessages(remote_port_id_,
@@ skipping 61 matching lines @@
 }
 
 void CheckMessagePortMsgMessage(MockRendererProcessHost* renderer_host,
                                 int expected_msg_route_id,
                                 std::string expected_data) {
   scoped_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(MessagePortMsg_Message::ID, msg->type());
   EXPECT_EQ(expected_msg_route_id, msg->routing_id());
   MessagePortMsg_Message::Param params;
   EXPECT_TRUE(MessagePortMsg_Message::Read(msg.get(), &params));
-  base::string16 data = get<0>(params);
+  base::string16 data = get<0>(params).message_as_string;
   EXPECT_EQ(base::ASCIIToUTF16(expected_data), data);
 }
 
 void CheckViewMsgWorkerConnected(MockRendererProcessHost* renderer_host,
                                  MockSharedWorkerConnector* connector) {
   scoped_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(ViewMsg_WorkerConnected::ID, msg->type());
   EXPECT_EQ(connector->route_id(), msg->routing_id());
 }
 
@@ skipping 76 matching lines @@
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
   connector->SendPostMessage("test1");
   EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host.get(), worker_msg_port_route_id, "test1");
 
   // When SharedWorker side sends MessagePortHostMsg_PostMessage,
   // SharedWorkerConnector side shuold receive MessagePortMsg_Message.
   const std::vector<int> empty_ids;
-  EXPECT_TRUE(renderer_host->OnMessageReceived(
-      new MessagePortHostMsg_PostMessage(connector->remote_port_id(),
-                                         base::ASCIIToUTF16("test2"),
-                                         empty_ids)));
+  EXPECT_TRUE(
+      renderer_host->OnMessageReceived(new MessagePortHostMsg_PostMessage(
+          connector->remote_port_id(),
+          MessagePortMessage(base::ASCIIToUTF16("test2")), empty_ids)));
   EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host.get(), connector->local_port_route_id(), "test2");
 
   // UpdateWorkerDependency should not be called.
   EXPECT_EQ(0, s_update_worker_dependency_call_count_);
 }
 
 TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) {
   // The first renderer host.
@@ skipping 73 matching lines @@
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
   connector0->SendPostMessage("test1");
   EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host0.get(), worker_msg_port_route_id1, "test1");
 
   // When SharedWorker side sends MessagePortHostMsg_PostMessage,
   // SharedWorkerConnector side shuold receive MessagePortMsg_Message.
   const std::vector<int> empty_ids;
-  EXPECT_TRUE(renderer_host0->OnMessageReceived(
-      new MessagePortHostMsg_PostMessage(connector0->remote_port_id(),
-                                         base::ASCIIToUTF16("test2"),
-                                         empty_ids)));
+  EXPECT_TRUE(
+      renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage(
+          connector0->remote_port_id(),
+          MessagePortMessage(base::ASCIIToUTF16("test2")), empty_ids)));
   EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host0.get(), connector0->local_port_route_id(), "test2");
 
   // The second renderer host.
   scoped_ptr<MockRendererProcessHost> renderer_host1(
       new MockRendererProcessHost(kProcessIDs[1],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
   scoped_ptr<MockSharedWorkerConnector> connector1(
@@ skipping 55 matching lines @@
 
   // When SharedWorkerConnector side sends MessagePortHostMsg_PostMessage,
   // SharedWorker side shuold receive MessagePortMsg_Message.
   connector1->SendPostMessage("test3");
   EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host0.get(), worker_msg_port_route_id2, "test3");
 
   // When SharedWorker side sends MessagePortHostMsg_PostMessage,
   // SharedWorkerConnector side shuold receive MessagePortMsg_Message.
-  EXPECT_TRUE(renderer_host0->OnMessageReceived(
-      new MessagePortHostMsg_PostMessage(connector1->remote_port_id(),
-                                         base::ASCIIToUTF16("test4"),
-                                         empty_ids)));
+  EXPECT_TRUE(
+      renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage(
+          connector1->remote_port_id(),
+          MessagePortMessage(base::ASCIIToUTF16("test4")), empty_ids)));
   EXPECT_EQ(1U, renderer_host1->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host1.get(), connector1->local_port_route_id(), "test4");
 
   EXPECT_EQ(1, s_update_worker_dependency_call_count_);
   renderer_host1.reset();
   // UpdateWorkerDependency should be called.
   EXPECT_EQ(2, s_update_worker_dependency_call_count_);
   EXPECT_EQ(0U, s_worker_dependency_added_ids_.size());
   EXPECT_EQ(1U, s_worker_dependency_removed_ids_.size());
@@ skipping 248 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