Headless: Remove obsolete Mojo code and some other obsolete APIs

headless/lib/browser/headless_web_contents_impl.cc

 // Copyright 2015 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 "headless/lib/browser/headless_web_contents_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 116 matching lines @@
         return;
       }
     }
   }
 
  private:
   HeadlessBrowserContextImpl* browser_context_;  // Not owned.
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
+namespace {
+void ForwardToServiceFactory(
+    const base::Callback<void(mojo::InterfaceRequest<TabSocket>)>&
+        service_factory,
+    mojo::ScopedMessagePipeHandle handle) {
+  service_factory.Run(mojo::MakeRequest<TabSocket>(std::move(handle)));
+}
+}  // namespace
+
 // static
 std::unique_ptr<HeadlessWebContentsImpl> HeadlessWebContentsImpl::Create(
     HeadlessWebContents::Builder* builder) {
   content::WebContents::CreateParams create_params(builder->browser_context_,
                                                    nullptr);
   create_params.initial_size = builder->window_size_;
 
   std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents =
       base::WrapUnique(new HeadlessWebContentsImpl(
           content::WebContents::Create(create_params),
           builder->browser_context_));
 
   if (builder->create_tab_socket_) {
     headless_web_contents->headless_tab_socket_ =
         base::MakeUnique<HeadlessTabSocketImpl>();
-    builder->AddMojoService(base::Bind(
-        &HeadlessTabSocketImpl::CreateMojoService,
-        base::Unretained(headless_web_contents->headless_tab_socket_.get())));
+
+    builder->mojo_services_.emplace_back(
+        TabSocket::Name_,
+        base::Bind(
+            &ForwardToServiceFactory,
+            base::Bind(
+                &HeadlessTabSocketImpl::CreateMojoService,
+                base::Unretained(
+                    headless_web_contents->headless_tab_socket_.get()))));
   }
 
   headless_web_contents->mojo_services_ = std::move(builder->mojo_services_);
   headless_web_contents->InitializeScreen(builder->window_size_);
   if (!headless_web_contents->OpenURL(builder->initial_url_))
     return nullptr;
   return headless_web_contents;
 }
 
 // static
@@ skipping 47 matching lines @@
 
   for (const MojoService& service : mojo_services_) {
     interface_registry->AddInterface(service.service_name,
                                      service.service_factory,
                                      browser()->BrowserMainThread());
   }
 
   browser_context_->SetFrameTreeNodeId(render_frame_host->GetProcess()->GetID(),
                                        render_frame_host->GetRoutingID(),
                                        render_frame_host->GetFrameTreeNodeId());
-
-  std::string devtools_agent_host_id =
-      content::DevToolsAgentHost::GetOrCreateFor(render_frame_host)->GetId();
-  render_frame_host_to_devtools_agent_host_id_[render_frame_host] =
-      devtools_agent_host_id;
-  devtools_agent_id_to_frame_tree_node_id_[devtools_agent_host_id] =
-      render_frame_host->GetFrameTreeNodeId();
 }
 
 void HeadlessWebContentsImpl::RenderFrameDeleted(
     content::RenderFrameHost* render_frame_host) {
   browser_context_->RemoveFrameTreeNode(
       render_frame_host->GetProcess()->GetID(),
       render_frame_host->GetRoutingID());
-
-  auto find_it =
-      render_frame_host_to_devtools_agent_host_id_.find(render_frame_host);
-  if (find_it == render_frame_host_to_devtools_agent_host_id_.end())
-    return;
-
-  devtools_agent_id_to_frame_tree_node_id_.erase(find_it->second);
-  render_frame_host_to_devtools_agent_host_id_.erase(find_it);
-}
-
-bool HeadlessWebContentsImpl::GetFrameTreeNodeIdForDevToolsAgentHostId(
-    const std::string& devtools_agent_host_id,
-    int* frame_tree_node_id) const {
-  const auto& find_it =
-      devtools_agent_id_to_frame_tree_node_id_.find(devtools_agent_host_id);
-  if (find_it == devtools_agent_id_to_frame_tree_node_id_.end())
-    return false;
-  *frame_tree_node_id = find_it->second;
-  return true;
 }
 
 std::string
 HeadlessWebContentsImpl::GetUntrustedDevToolsFrameIdForFrameTreeNodeId(
     int process_id,
     int frame_tree_node_id) const {
   return content::DevToolsAgentHost::
       GetUntrustedDevToolsFrameIdForFrameTreeNodeId(process_id,
                                                     frame_tree_node_id);
 }
@@ skipping 120 matching lines @@
   initial_url_ = initial_url;
   return *this;
 }
 
 HeadlessWebContents::Builder& HeadlessWebContents::Builder::SetWindowSize(
     const gfx::Size& size) {
   window_size_ = size;
   return *this;
 }
 
-HeadlessWebContents::Builder& HeadlessWebContents::Builder::AddMojoService(
-    const std::string& service_name,
-    const base::Callback<void(mojo::ScopedMessagePipeHandle)>&
-        service_factory) {
-  mojo_services_.emplace_back(service_name, service_factory);
-  return *this;
-}
-
 HeadlessWebContents::Builder& HeadlessWebContents::Builder::CreateTabSocket(
     bool create_tab_socket) {
   create_tab_socket_ = create_tab_socket;
   return *this;
 }
 
 HeadlessWebContents* HeadlessWebContents::Builder::Build() {
   return browser_context_->CreateWebContents(this);
 }
 
 HeadlessWebContents::Builder::MojoService::MojoService() {}
 
 HeadlessWebContents::Builder::MojoService::MojoService(
     const std::string& service_name,
     const base::Callback<void(mojo::ScopedMessagePipeHandle)>& service_factory)
     : service_name(service_name), service_factory(service_factory) {}
 
 HeadlessWebContents::Builder::MojoService::~MojoService() {}
 
 }  // namespace headless