Convert //content/browser from scoped_ptr to std::unique_ptr

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>
 #include <set>
 #include <vector>
 
 #include "base/atomic_sequence_num.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/shared_worker/shared_worker_message_filter.h"
-#include "content/browser/shared_worker/shared_worker_service_impl.h"
 #include "content/browser/shared_worker/worker_storage_partition.h"
 #include "content/common/message_port_messages.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.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"
 
@@ skipping 45 matching lines @@
     s_worker_dependency_added_ids_ = added_ids;
     s_worker_dependency_removed_ids_ = removed_ids;
   }
   static bool MockTryIncrementWorkerRefCount(int worker_process_id) {
     base::AutoLock lock(s_lock_);
     return s_running_process_id_set_.find(worker_process_id) !=
            s_running_process_id_set_.end();
   }
 
   TestBrowserThreadBundle browser_thread_bundle_;
-  scoped_ptr<TestBrowserContext> browser_context_;
-  scoped_ptr<WorkerStoragePartition> partition_;
+  std::unique_ptr<TestBrowserContext> browser_context_;
+  std::unique_ptr<WorkerStoragePartition> partition_;
   static int s_update_worker_dependency_call_count_;
   static std::vector<int> s_worker_dependency_added_ids_;
   static std::vector<int> s_worker_dependency_removed_ids_;
   static base::Lock s_lock_;
   static std::set<int> s_running_process_id_set_;
   DISALLOW_COPY_AND_ASSIGN(SharedWorkerServiceImplTest);
 };
 
 // static
 int SharedWorkerServiceImplTest::s_update_worker_dependency_call_count_;
@@ skipping 83 matching lines @@
     SharedWorkerServiceImplTest::RegisterRunningProcessID(process_id);
   }
 
   ~MockRendererProcessHost() {
     SharedWorkerServiceImplTest::UnregisterRunningProcessID(process_id_);
     message_filter_->Close();
     worker_filter_->Close();
   }
 
   bool OnMessageReceived(IPC::Message* message) {
-    scoped_ptr<IPC::Message> msg(message);
+    std::unique_ptr<IPC::Message> msg(message);
     const bool ret = message_filter_->OnMessageReceived(*message) ||
                      worker_filter_->OnMessageReceived(*message);
     if (message->is_sync()) {
       CHECK(!queued_messages_.empty());
       const IPC::Message* response_msg = queued_messages_.back();
       IPC::SyncMessage* sync_msg = static_cast<IPC::SyncMessage*>(message);
-      scoped_ptr<IPC::MessageReplyDeserializer> reply_serializer(
+      std::unique_ptr<IPC::MessageReplyDeserializer> reply_serializer(
           sync_msg->GetReplyDeserializer());
       bool result = reply_serializer->SerializeOutputParameters(*response_msg);
       CHECK(result);
       queued_messages_.pop_back();
     }
     return ret;
   }
 
   size_t QueuedMessageCount() const { return queued_messages_.size(); }
 
-  scoped_ptr<IPC::Message> PopMessage() {
+  std::unique_ptr<IPC::Message> PopMessage() {
     CHECK(queued_messages_.size());
-    scoped_ptr<IPC::Message> msg(*queued_messages_.begin());
+    std::unique_ptr<IPC::Message> msg(*queued_messages_.begin());
     queued_messages_.weak_erase(queued_messages_.begin());
     return msg;
   }
 
   void FastShutdownIfPossible() {
     SharedWorkerServiceImplTest::UnregisterRunningProcessID(process_id_);
   }
 
  private:
   const int process_id_;
@@ skipping 99 matching lines @@
   int local_port_id_;
   ViewHostMsg_CreateWorker_Reply create_worker_reply_;
 };
 
 void CheckWorkerProcessMsgCreateWorker(
     MockRendererProcessHost* renderer_host,
     const std::string& expected_url,
     const std::string& expected_name,
     blink::WebContentSecurityPolicyType expected_security_policy_type,
     int* route_id) {
-  scoped_ptr<IPC::Message> msg(renderer_host->PopMessage());
+  std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type());
   base::Tuple<WorkerProcessMsg_CreateWorker_Params> param;
   EXPECT_TRUE(WorkerProcessMsg_CreateWorker::Read(msg.get(), &param));
   EXPECT_EQ(GURL(expected_url), base::get<0>(param).url);
   EXPECT_EQ(base::ASCIIToUTF16(expected_name), base::get<0>(param).name);
   EXPECT_EQ(expected_security_policy_type,
             base::get<0>(param).security_policy_type);
   *route_id = base::get<0>(param).route_id;
 }
 
 void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host,
                                MockSharedWorkerConnector* connector) {
-  scoped_ptr<IPC::Message> msg(renderer_host->PopMessage());
+  std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(ViewMsg_WorkerCreated::ID, msg->type());
   EXPECT_EQ(connector->route_id(), msg->routing_id());
 }
 
 void CheckMessagePortMsgMessagesQueued(MockRendererProcessHost* renderer_host,
                                        MockSharedWorkerConnector* connector) {
-  scoped_ptr<IPC::Message> msg(renderer_host->PopMessage());
+  std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(MessagePortMsg_MessagesQueued::ID, msg->type());
   EXPECT_EQ(connector->temporary_remote_port_route_id(), msg->routing_id());
 }
 
 void CheckWorkerMsgConnect(MockRendererProcessHost* renderer_host,
                            int expected_msg_route_id,
                            int expected_sent_message_port_id,
                            int* routing_id) {
-  scoped_ptr<IPC::Message> msg(renderer_host->PopMessage());
+  std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(WorkerMsg_Connect::ID, msg->type());
   EXPECT_EQ(expected_msg_route_id, msg->routing_id());
   WorkerMsg_Connect::Param params;
   EXPECT_TRUE(WorkerMsg_Connect::Read(msg.get(), &params));
   int port_id = base::get<0>(params);
   *routing_id = base::get<1>(params);
   EXPECT_EQ(expected_sent_message_port_id, port_id);
 }
 
 void CheckMessagePortMsgMessage(MockRendererProcessHost* renderer_host,
                                 int expected_msg_route_id,
                                 std::string expected_data) {
-  scoped_ptr<IPC::Message> msg(renderer_host->PopMessage());
+  std::unique_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 = base::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());
+  std::unique_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(ViewMsg_WorkerConnected::ID, msg->type());
   EXPECT_EQ(connector->route_id(), msg->routing_id());
 }
 
 }  // namespace
 
 TEST_F(SharedWorkerServiceImplTest, BasicTest) {
-  scoped_ptr<MockRendererProcessHost> renderer_host(
+  std::unique_ptr<MockRendererProcessHost> renderer_host(
       new MockRendererProcessHost(kProcessIDs[0],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
-  scoped_ptr<MockSharedWorkerConnector> connector(
+  std::unique_ptr<MockSharedWorkerConnector> connector(
       new MockSharedWorkerConnector(renderer_host.get()));
   int worker_route_id;
   int worker_msg_port_route_id;
 
   // SharedWorkerConnector creates two message ports and sends
   // ViewHostMsg_CreateWorker.
   connector->Create("http://example.com/w.js",
                     "name",
                     kDocumentIDs[0],
                     kRenderFrameRouteIDs[0]);
@@ skipping 72 matching lines @@
   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.
-  scoped_ptr<MockRendererProcessHost> renderer_host0(
+  std::unique_ptr<MockRendererProcessHost> renderer_host0(
       new MockRendererProcessHost(kProcessIDs[0],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
-  scoped_ptr<MockSharedWorkerConnector> connector0(
+  std::unique_ptr<MockSharedWorkerConnector> connector0(
       new MockSharedWorkerConnector(renderer_host0.get()));
   int worker_route_id;
   int worker_msg_port_route_id1;
 
   // SharedWorkerConnector creates two message ports and sends
   // ViewHostMsg_CreateWorker.
   connector0->Create("http://example.com/w.js",
                      "name",
                      kDocumentIDs[0],
                      kRenderFrameRouteIDs[0]);
@@ skipping 67 matching lines @@
   const std::vector<TransferredMessagePort> empty_ports;
   EXPECT_TRUE(
       renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage(
           connector0->remote_port_id(),
           MessagePortMessage(base::ASCIIToUTF16("test2")), empty_ports)));
   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(
+  std::unique_ptr<MockRendererProcessHost> renderer_host1(
       new MockRendererProcessHost(kProcessIDs[1],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
-  scoped_ptr<MockSharedWorkerConnector> connector1(
+  std::unique_ptr<MockSharedWorkerConnector> connector1(
       new MockSharedWorkerConnector(renderer_host1.get()));
   int worker_msg_port_route_id2;
 
   // UpdateWorkerDependency should not be called yet.
   EXPECT_EQ(0, s_update_worker_dependency_call_count_);
 
   // SharedWorkerConnector creates two message ports and sends
   // ViewHostMsg_CreateWorker.
   connector1->Create("http://example.com/w.js",
                      "name",
@@ skipping 64 matching lines @@
   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());
   EXPECT_EQ(kProcessIDs[0], s_worker_dependency_removed_ids_[0]);
 }
 
 TEST_F(SharedWorkerServiceImplTest, CreateWorkerTest) {
   // The first renderer host.
-  scoped_ptr<MockRendererProcessHost> renderer_host0(
+  std::unique_ptr<MockRendererProcessHost> renderer_host0(
       new MockRendererProcessHost(kProcessIDs[0],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
   // The second renderer host.
-  scoped_ptr<MockRendererProcessHost> renderer_host1(
+  std::unique_ptr<MockRendererProcessHost> renderer_host1(
       new MockRendererProcessHost(kProcessIDs[1],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
   int worker_route_id;
 
   // Normal case.
   {
-    scoped_ptr<MockSharedWorkerConnector> connector0(
+    std::unique_ptr<MockSharedWorkerConnector> connector0(
         new MockSharedWorkerConnector(renderer_host0.get()));
-    scoped_ptr<MockSharedWorkerConnector> connector1(
+    std::unique_ptr<MockSharedWorkerConnector> connector1(
         new MockSharedWorkerConnector(renderer_host1.get()));
     connector0->Create("http://example.com/w1.js",
                        "name1",
                        kDocumentIDs[0],
                        kRenderFrameRouteIDs[0]);
     EXPECT_NE(MSG_ROUTING_NONE, connector0->route_id());
     EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
     RunAllPendingInMessageLoop();
     EXPECT_EQ(2U, renderer_host0->QueuedMessageCount());
     CheckWorkerProcessMsgCreateWorker(renderer_host0.get(),
                                       "http://example.com/w1.js",
                                       "name1",
                                       blink::WebContentSecurityPolicyTypeReport,
                                       &worker_route_id);
     CheckViewMsgWorkerCreated(renderer_host0.get(), connector0.get());
     connector1->Create("http://example.com/w1.js",
                        "name1",
                        kDocumentIDs[1],
                        kRenderFrameRouteIDs[1]);
     EXPECT_NE(MSG_ROUTING_NONE, connector1->route_id());
     EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
     RunAllPendingInMessageLoop();
     EXPECT_EQ(1U, renderer_host1->QueuedMessageCount());
     CheckViewMsgWorkerCreated(renderer_host1.get(), connector1.get());
   }
 
   // Normal case (URL mismatch).
   {
-    scoped_ptr<MockSharedWorkerConnector> connector0(
+    std::unique_ptr<MockSharedWorkerConnector> connector0(
         new MockSharedWorkerConnector(renderer_host0.get()));
-    scoped_ptr<MockSharedWorkerConnector> connector1(
+    std::unique_ptr<MockSharedWorkerConnector> connector1(
         new MockSharedWorkerConnector(renderer_host1.get()));
     connector0->Create("http://example.com/w2.js",
                        "name2",
                        kDocumentIDs[0],
                        kRenderFrameRouteIDs[0]);
     EXPECT_NE(MSG_ROUTING_NONE, connector0->route_id());
     EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
     RunAllPendingInMessageLoop();
     EXPECT_EQ(2U, renderer_host0->QueuedMessageCount());
     CheckWorkerProcessMsgCreateWorker(renderer_host0.get(),
                                       "http://example.com/w2.js",
                                       "name2",
                                       blink::WebContentSecurityPolicyTypeReport,
                                       &worker_route_id);
     CheckViewMsgWorkerCreated(renderer_host0.get(), connector0.get());
     connector1->Create("http://example.com/w2x.js",
                        "name2",
                        kDocumentIDs[1],
                        kRenderFrameRouteIDs[1]);
     EXPECT_EQ(MSG_ROUTING_NONE, connector1->route_id());
     EXPECT_EQ(blink::WebWorkerCreationErrorURLMismatch,
               connector1->creation_error());
     EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
     RunAllPendingInMessageLoop();
     EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
   }
 
   // Pending case.
   {
-    scoped_ptr<MockSharedWorkerConnector> connector0(
+    std::unique_ptr<MockSharedWorkerConnector> connector0(
         new MockSharedWorkerConnector(renderer_host0.get()));
-    scoped_ptr<MockSharedWorkerConnector> connector1(
+    std::unique_ptr<MockSharedWorkerConnector> connector1(
         new MockSharedWorkerConnector(renderer_host1.get()));
     connector0->Create("http://example.com/w3.js",
                        "name3",
                        kDocumentIDs[0],
                        kRenderFrameRouteIDs[0]);
     EXPECT_NE(MSG_ROUTING_NONE, connector0->route_id());
     EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
     connector1->Create("http://example.com/w3.js",
                        "name3",
                        kDocumentIDs[1],
                        kRenderFrameRouteIDs[1]);
     EXPECT_NE(MSG_ROUTING_NONE, connector1->route_id());
     EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
     RunAllPendingInMessageLoop();
     EXPECT_EQ(2U, renderer_host0->QueuedMessageCount());
     CheckWorkerProcessMsgCreateWorker(renderer_host0.get(),
                                       "http://example.com/w3.js",
                                       "name3",
                                       blink::WebContentSecurityPolicyTypeReport,
                                       &worker_route_id);
     CheckViewMsgWorkerCreated(renderer_host0.get(), connector0.get());
     EXPECT_EQ(1U, renderer_host1->QueuedMessageCount());
     CheckViewMsgWorkerCreated(renderer_host1.get(), connector1.get());
   }
 
   // Pending case (URL mismatch).
   {
-    scoped_ptr<MockSharedWorkerConnector> connector0(
+    std::unique_ptr<MockSharedWorkerConnector> connector0(
         new MockSharedWorkerConnector(renderer_host0.get()));
-    scoped_ptr<MockSharedWorkerConnector> connector1(
+    std::unique_ptr<MockSharedWorkerConnector> connector1(
         new MockSharedWorkerConnector(renderer_host1.get()));
     connector0->Create("http://example.com/w4.js",
                        "name4",
                        kDocumentIDs[0],
                        kRenderFrameRouteIDs[0]);
     EXPECT_NE(MSG_ROUTING_NONE, connector0->route_id());
     EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
     connector1->Create("http://example.com/w4x.js",
                        "name4",
                        kDocumentIDs[1],
                        kRenderFrameRouteIDs[1]);
     EXPECT_EQ(MSG_ROUTING_NONE, connector1->route_id());
     EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
     RunAllPendingInMessageLoop();
     EXPECT_EQ(2U, renderer_host0->QueuedMessageCount());
     CheckWorkerProcessMsgCreateWorker(renderer_host0.get(),
                                       "http://example.com/w4.js",
                                       "name4",
                                       blink::WebContentSecurityPolicyTypeReport,
                                       &worker_route_id);
     CheckViewMsgWorkerCreated(renderer_host0.get(), connector0.get());
     EXPECT_EQ(0U, renderer_host1->QueuedMessageCount());
   }
 }
 
 TEST_F(SharedWorkerServiceImplTest, CreateWorkerRaceTest) {
   // Create three renderer hosts.
-  scoped_ptr<MockRendererProcessHost> renderer_host0(
+  std::unique_ptr<MockRendererProcessHost> renderer_host0(
       new MockRendererProcessHost(kProcessIDs[0],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
-  scoped_ptr<MockRendererProcessHost> renderer_host1(
+  std::unique_ptr<MockRendererProcessHost> renderer_host1(
       new MockRendererProcessHost(kProcessIDs[1],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
-  scoped_ptr<MockRendererProcessHost> renderer_host2(
+  std::unique_ptr<MockRendererProcessHost> renderer_host2(
       new MockRendererProcessHost(kProcessIDs[2],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
   int worker_route_id;
 
-  scoped_ptr<MockSharedWorkerConnector> connector0(
+  std::unique_ptr<MockSharedWorkerConnector> connector0(
       new MockSharedWorkerConnector(renderer_host0.get()));
-  scoped_ptr<MockSharedWorkerConnector> connector1(
+  std::unique_ptr<MockSharedWorkerConnector> connector1(
       new MockSharedWorkerConnector(renderer_host1.get()));
-  scoped_ptr<MockSharedWorkerConnector> connector2(
+  std::unique_ptr<MockSharedWorkerConnector> connector2(
       new MockSharedWorkerConnector(renderer_host2.get()));
   connector0->Create("http://example.com/w1.js",
                      "name1",
                      kDocumentIDs[0],
                      kRenderFrameRouteIDs[0]);
   EXPECT_NE(MSG_ROUTING_NONE, connector0->route_id());
   EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
   RunAllPendingInMessageLoop();
   EXPECT_EQ(2U, renderer_host0->QueuedMessageCount());
   CheckWorkerProcessMsgCreateWorker(renderer_host0.get(),
@@ skipping 25 matching lines @@
                      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());
 }
 
 TEST_F(SharedWorkerServiceImplTest, CreateWorkerRaceTest2) {
   // Create three renderer hosts.
-  scoped_ptr<MockRendererProcessHost> renderer_host0(
+  std::unique_ptr<MockRendererProcessHost> renderer_host0(
       new MockRendererProcessHost(kProcessIDs[0],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
-  scoped_ptr<MockRendererProcessHost> renderer_host1(
+  std::unique_ptr<MockRendererProcessHost> renderer_host1(
       new MockRendererProcessHost(kProcessIDs[1],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
-  scoped_ptr<MockRendererProcessHost> renderer_host2(
+  std::unique_ptr<MockRendererProcessHost> renderer_host2(
       new MockRendererProcessHost(kProcessIDs[2],
                                   browser_context_->GetResourceContext(),
                                   *partition_.get()));
   int worker_route_id;
 
-  scoped_ptr<MockSharedWorkerConnector> connector0(
+  std::unique_ptr<MockSharedWorkerConnector> connector0(
       new MockSharedWorkerConnector(renderer_host0.get()));
-  scoped_ptr<MockSharedWorkerConnector> connector1(
+  std::unique_ptr<MockSharedWorkerConnector> connector1(
       new MockSharedWorkerConnector(renderer_host1.get()));
-  scoped_ptr<MockSharedWorkerConnector> connector2(
+  std::unique_ptr<MockSharedWorkerConnector> connector2(
       new MockSharedWorkerConnector(renderer_host2.get()));
   connector0->Create("http://example.com/w1.js",
                      "name1",
                      kDocumentIDs[0],
                      kRenderFrameRouteIDs[0]);
   EXPECT_NE(MSG_ROUTING_NONE, connector0->route_id());
   EXPECT_EQ(0U, renderer_host0->QueuedMessageCount());
   renderer_host0->FastShutdownIfPossible();
 
   connector1->Create("http://example.com/w1.js",
@@ skipping 16 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