Add HeadlessTabSocket

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 13 matching lines @@
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/origin_util.h"
 #include "headless/lib/browser/headless_browser_context_impl.h"
 #include "headless/lib/browser/headless_browser_impl.h"
 #include "headless/lib/browser/headless_browser_main_parts.h"
 #include "headless/lib/browser/headless_devtools_client_impl.h"
+#include "headless/lib/browser/headless_tab_socket_impl.h"
 #include "printing/features/features.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
 #include "headless/lib/browser/headless_print_manager.h"
 #endif
 
 namespace headless {
 
 // static
@@ skipping 94 matching lines @@
     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())));
+  }
+
   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
 std::unique_ptr<HeadlessWebContentsImpl>
 HeadlessWebContentsImpl::CreateFromWebContents(
@@ skipping 127 matching lines @@
 }
 
 HeadlessBrowserImpl* HeadlessWebContentsImpl::browser() const {
   return browser_context_->browser();
 }
 
 HeadlessBrowserContextImpl* HeadlessWebContentsImpl::browser_context() const {
   return browser_context_;
 }
 
+HeadlessTabSocket* HeadlessWebContentsImpl::GetHeadlessTabSocket() const {
+  return headless_tab_socket_.get();
+}
+
 HeadlessWebContents::Builder::Builder(
     HeadlessBrowserContextImpl* browser_context)
     : browser_context_(browser_context),
       window_size_(browser_context->options()->window_size()) {}
 
 HeadlessWebContents::Builder::~Builder() = default;
 
 HeadlessWebContents::Builder::Builder(Builder&&) = default;
 
 HeadlessWebContents::Builder& HeadlessWebContents::Builder::SetInitialURL(
     const GURL& initial_url) {
   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