BASELINE: Update Chromium to 70.0.3538.78

Change-Id: Ie634710bf039e26c1957f4ae45e101bd4c434ae7
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

17 files changed, 138 insertions, 73 deletions

diff --git a/chromium/headless/lib/browser/devtools_api/domain_h.template b/chromium/headless/lib/browser/devtools_api/domain_h.template
index dd28794e786..28f61101f88 100644
--- a/chromium/headless/lib/browser/devtools_api/domain_h.template
+++ b/chromium/headless/lib/browser/devtools_api/domain_h.template
@@ -117,7 +117,7 @@ class HEADLESS_EXPORT Domain {
 
   internal::MessageDispatcher* dispatcher_;  // Not owned.
   {% if "events" in domain %}
-  base::ObserverList<ExperimentalObserver> observers_;
+  base::ObserverList<ExperimentalObserver>::Unchecked observers_;
   {% endif %}
 
   {% if "events" in domain %}
diff --git a/chromium/headless/lib/browser/headless_browser_context_impl.cc b/chromium/headless/lib/browser/headless_browser_context_impl.cc
index 9862f0f1199..0e59b9c8cc2 100644
--- a/chromium/headless/lib/browser/headless_browser_context_impl.cc
+++ b/chromium/headless/lib/browser/headless_browser_context_impl.cc
@@ -151,7 +151,7 @@ void HeadlessBrowserContextImpl::SetDevToolsFrameToken(
     const base::UnguessableToken& devtools_frame_token,
     int frame_tree_node_id) {
   base::AutoLock lock(devtools_frame_token_map_lock_);
-  devtools_frame_token_map_[std::make_pair(
+  devtools_frame_token_map_[content::GlobalFrameRoutingId(
       render_process_id, render_frame_routing_id)] = devtools_frame_token;
   frame_tree_node_id_to_devtools_frame_token_map_[frame_tree_node_id] =
       devtools_frame_token;
@@ -162,8 +162,8 @@ void HeadlessBrowserContextImpl::RemoveDevToolsFrameToken(
     int render_frame_routing_id,
     int frame_tree_node_id) {
   base::AutoLock lock(devtools_frame_token_map_lock_);
-  devtools_frame_token_map_.erase(
-      std::make_pair(render_process_id, render_frame_routing_id));
+  devtools_frame_token_map_.erase(content::GlobalFrameRoutingId(
+      render_process_id, render_frame_routing_id));
   frame_tree_node_id_to_devtools_frame_token_map_.erase(frame_tree_node_id);
 }
 
@@ -172,7 +172,7 @@ const base::UnguessableToken* HeadlessBrowserContextImpl::GetDevToolsFrameToken(
     int render_frame_id) const {
   base::AutoLock lock(devtools_frame_token_map_lock_);
   const auto& find_it = devtools_frame_token_map_.find(
-      std::make_pair(render_process_id, render_frame_id));
+      content::GlobalFrameRoutingId(render_process_id, render_frame_id));
   if (find_it == devtools_frame_token_map_.end())
     return nullptr;
   return &find_it->second;
@@ -213,6 +213,10 @@ base::FilePath HeadlessBrowserContextImpl::GetPath() const {
   return path_;
 }
 
+base::FilePath HeadlessBrowserContextImpl::GetCachePath() const {
+  return path_;
+}
+
 bool HeadlessBrowserContextImpl::IsOffTheRecord() const {
   return context_options_->incognito_mode();
 }
diff --git a/chromium/headless/lib/browser/headless_browser_context_impl.h b/chromium/headless/lib/browser/headless_browser_context_impl.h
index 3eb76846361..d192b101783 100644
--- a/chromium/headless/lib/browser/headless_browser_context_impl.h
+++ b/chromium/headless/lib/browser/headless_browser_context_impl.h
@@ -13,6 +13,7 @@
 #include "base/files/file_path.h"
 #include "base/unguessable_token.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/global_routing_id.h"
 #include "content/public/browser/resource_context.h"
 #include "headless/lib/browser/headless_browser_context_options.h"
 #include "headless/lib/browser/headless_network_conditions.h"
@@ -65,6 +66,7 @@ class HEADLESS_EXPORT HeadlessBrowserContextImpl final
   std::unique_ptr<content::ZoomLevelDelegate> CreateZoomLevelDelegate(
       const base::FilePath& partition_path) override;
   base::FilePath GetPath() const override;
+  base::FilePath GetCachePath() const override;
   bool IsOffTheRecord() const override;
   content::ResourceContext* GetResourceContext() override;
   content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
@@ -138,7 +140,7 @@ class HEADLESS_EXPORT HeadlessBrowserContextImpl final
   // TODO(alexclarke): Remove if we can add DevTools frame token ID to
   // ResourceRequestInfo. See https://crbug.com/715541
   mutable base::Lock devtools_frame_token_map_lock_;
-  base::flat_map<std::pair<int, int>, base::UnguessableToken>
+  base::flat_map<content::GlobalFrameRoutingId, base::UnguessableToken>
       devtools_frame_token_map_;
   base::flat_map<int, base::UnguessableToken>
       frame_tree_node_id_to_devtools_frame_token_map_;
diff --git a/chromium/headless/lib/browser/headless_content_browser_client.cc b/chromium/headless/lib/browser/headless_content_browser_client.cc
index 85f54f05d9b..e67fed7c969 100644
--- a/chromium/headless/lib/browser/headless_content_browser_client.cc
+++ b/chromium/headless/lib/browser/headless_content_browser_client.cc
@@ -277,6 +277,11 @@ void HeadlessContentBrowserClient::AppendExtraCommandLineSwitches(
   }
 }
 
+std::string HeadlessContentBrowserClient::GetAcceptLangs(
+    content::BrowserContext* context) {
+  return browser_->options()->accept_language;
+}
+
 void HeadlessContentBrowserClient::AllowCertificateError(
     content::WebContents* web_contents,
     int cert_error,
@@ -324,4 +329,13 @@ bool HeadlessContentBrowserClient::DoesSiteRequireDedicatedProcess(
       ->site_per_process();
 }
 
+bool HeadlessContentBrowserClient::ShouldEnableStrictSiteIsolation() {
+  // TODO(lukasza): https://crbug.com/869494: Instead of overriding
+  // ShouldEnableStrictSiteIsolation, //headless should inherit the default
+  // site-per-process setting from //content - this way tools (tests, but also
+  // production cases like screenshot or pdf generation) based on //headless
+  // will use a mode that is actually shipping in Chrome.
+  return false;
+}
+
 }  // namespace headless
diff --git a/chromium/headless/lib/browser/headless_content_browser_client.h b/chromium/headless/lib/browser/headless_content_browser_client.h
index 2effa5f8fb0..1393f43719a 100644
--- a/chromium/headless/lib/browser/headless_content_browser_client.h
+++ b/chromium/headless/lib/browser/headless_content_browser_client.h
@@ -40,7 +40,7 @@ class HeadlessContentBrowserClient : public content::ContentBrowserClient {
 #endif
   void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
                                       int child_process_id) override;
-
+  std::string GetAcceptLangs(content::BrowserContext* context) override;
   void AllowCertificateError(
       content::WebContents* web_contents,
       int cert_error,
@@ -51,17 +51,15 @@ class HeadlessContentBrowserClient : public content::ContentBrowserClient {
       bool expired_previous_decision,
       const base::Callback<void(content::CertificateRequestResultType)>&
           callback) override;
-
   void SelectClientCertificate(
       content::WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
       net::ClientCertIdentityList client_certs,
       std::unique_ptr<content::ClientCertificateDelegate> delegate) override;
-
   void ResourceDispatcherHostCreated() override;
-
   bool DoesSiteRequireDedicatedProcess(content::BrowserContext* browser_context,
                                        const GURL& effective_site_url) override;
+  bool ShouldEnableStrictSiteIsolation() override;
 
  private:
   std::unique_ptr<base::Value> GetBrowserServiceManifestOverlay();
diff --git a/chromium/headless/lib/browser/headless_devtools_manager_delegate.cc b/chromium/headless/lib/browser/headless_devtools_manager_delegate.cc
index 963c856e452..bd611875403 100644
--- a/chromium/headless/lib/browser/headless_devtools_manager_delegate.cc
+++ b/chromium/headless/lib/browser/headless_devtools_manager_delegate.cc
@@ -22,16 +22,15 @@ HeadlessDevToolsManagerDelegate::HeadlessDevToolsManagerDelegate(
 
 HeadlessDevToolsManagerDelegate::~HeadlessDevToolsManagerDelegate() = default;
 
-bool HeadlessDevToolsManagerDelegate::HandleCommand(
+void HeadlessDevToolsManagerDelegate::HandleCommand(
     content::DevToolsAgentHost* agent_host,
     content::DevToolsAgentHostClient* client,
-    base::DictionaryValue* command) {
-  if (!browser_)
-    return false;
+    std::unique_ptr<base::DictionaryValue> command,
+    const std::string& message,
+    NotHandledCallback callback) {
   DCHECK(sessions_.find(client) != sessions_.end());
-  auto response = sessions_[client]->dispatcher()->dispatch(
-      protocol::toProtocolValue(command, 1000));
-  return response != protocol::DispatchResponse::Status::kFallThrough;
+  sessions_[client]->HandleCommand(std::move(command), message,
+                                   std::move(callback));
 }
 
 scoped_refptr<content::DevToolsAgentHost>
@@ -73,4 +72,44 @@ void HeadlessDevToolsManagerDelegate::ClientDetached(
   sessions_.erase(client);
 }
 
+std::vector<content::BrowserContext*>
+HeadlessDevToolsManagerDelegate::GetBrowserContexts() {
+  std::vector<content::BrowserContext*> contexts;
+  for (auto* context : browser_->GetAllBrowserContexts()) {
+    if (context != browser_->GetDefaultBrowserContext())
+      contexts.push_back(HeadlessBrowserContextImpl::From(context));
+  }
+  return contexts;
+}
+content::BrowserContext*
+HeadlessDevToolsManagerDelegate::GetDefaultBrowserContext() {
+  return HeadlessBrowserContextImpl::From(browser_->GetDefaultBrowserContext());
+}
+
+content::BrowserContext*
+HeadlessDevToolsManagerDelegate::CreateBrowserContext() {
+  auto builder = browser_->CreateBrowserContextBuilder();
+  builder.SetIncognitoMode(true);
+  HeadlessBrowserContext* browser_context = builder.Build();
+  return HeadlessBrowserContextImpl::From(browser_context);
+}
+
+void HeadlessDevToolsManagerDelegate::DisposeBrowserContext(
+    content::BrowserContext* browser_context,
+    DisposeCallback callback) {
+  HeadlessBrowserContextImpl* context =
+      HeadlessBrowserContextImpl::From(browser_context);
+  std::vector<HeadlessWebContents*> web_contents = context->GetAllWebContents();
+  while (!web_contents.empty()) {
+    for (auto* wc : web_contents)
+      wc->Close();
+    // Since HeadlessWebContents::Close spawns a nested run loop to await
+    // closing, new web_contents could be opened. We need to re-query pages and
+    // close them too.
+    web_contents = context->GetAllWebContents();
+  }
+  context->Close();
+  std::move(callback).Run(true, "");
+}
+
 }  // namespace headless
diff --git a/chromium/headless/lib/browser/headless_devtools_manager_delegate.h b/chromium/headless/lib/browser/headless_devtools_manager_delegate.h
index ae8da6ac2f6..eb40d4046a5 100644
--- a/chromium/headless/lib/browser/headless_devtools_manager_delegate.h
+++ b/chromium/headless/lib/browser/headless_devtools_manager_delegate.h
@@ -29,9 +29,11 @@ class HeadlessDevToolsManagerDelegate
   ~HeadlessDevToolsManagerDelegate() override;
 
   // DevToolsManagerDelegate implementation:
-  bool HandleCommand(content::DevToolsAgentHost* agent_host,
+  void HandleCommand(content::DevToolsAgentHost* agent_host,
                      content::DevToolsAgentHostClient* client,
-                     base::DictionaryValue* command) override;
+                     std::unique_ptr<base::DictionaryValue> command,
+                     const std::string& message,
+                     NotHandledCallback callback) override;
   scoped_refptr<content::DevToolsAgentHost> CreateNewTarget(
       const GURL& url) override;
   std::string GetDiscoveryPageHTML() override;
@@ -41,6 +43,12 @@ class HeadlessDevToolsManagerDelegate
   void ClientDetached(content::DevToolsAgentHost* agent_host,
                       content::DevToolsAgentHostClient* client) override;
 
+  std::vector<content::BrowserContext*> GetBrowserContexts() override;
+  content::BrowserContext* GetDefaultBrowserContext() override;
+  content::BrowserContext* CreateBrowserContext() override;
+  void DisposeBrowserContext(content::BrowserContext* context,
+                             DisposeCallback callback) override;
+
  private:
   base::WeakPtr<HeadlessBrowserImpl> browser_;
   std::map<content::DevToolsAgentHostClient*,
diff --git a/chromium/headless/lib/browser/headless_focus_client.h b/chromium/headless/lib/browser/headless_focus_client.h
index a218089ec7d..0739bfa3d64 100644
--- a/chromium/headless/lib/browser/headless_focus_client.h
+++ b/chromium/headless/lib/browser/headless_focus_client.h
@@ -32,7 +32,8 @@ class HeadlessFocusClient : public aura::client::FocusClient,
 
   aura::Window* focused_window_;
   ScopedObserver<aura::Window, aura::WindowObserver> observer_manager_;
-  base::ObserverList<aura::client::FocusChangeObserver> focus_observers_;
+  base::ObserverList<aura::client::FocusChangeObserver>::Unchecked
+      focus_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessFocusClient);
 };
diff --git a/chromium/headless/lib/browser/headless_permission_manager.cc b/chromium/headless/lib/browser/headless_permission_manager.cc
index ce2b687e60d..46fa0038350 100644
--- a/chromium/headless/lib/browser/headless_permission_manager.cc
+++ b/chromium/headless/lib/browser/headless_permission_manager.cc
@@ -73,8 +73,8 @@ HeadlessPermissionManager::GetPermissionStatusForFrame(
 
 int HeadlessPermissionManager::SubscribePermissionStatusChange(
     content::PermissionType permission,
+    content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
-    const GURL& embedding_origin,
     const base::Callback<void(blink::mojom::PermissionStatus)>& callback) {
   return content::PermissionController::kNoPendingOperation;
 }
diff --git a/chromium/headless/lib/browser/headless_permission_manager.h b/chromium/headless/lib/browser/headless_permission_manager.h
index 86488a0a7d1..95cadf7209a 100644
--- a/chromium/headless/lib/browser/headless_permission_manager.h
+++ b/chromium/headless/lib/browser/headless_permission_manager.h
@@ -49,8 +49,8 @@ class HeadlessPermissionManager : public content::PermissionControllerDelegate {
       const GURL& requesting_origin) override;
   int SubscribePermissionStatusChange(
       content::PermissionType permission,
+      content::RenderFrameHost* render_frame_host,
       const GURL& requesting_origin,
-      const GURL& embedding_origin,
       const base::Callback<void(blink::mojom::PermissionStatus)>& callback)
       override;
   void UnsubscribePermissionStatusChange(int subscription_id) override;
diff --git a/chromium/headless/lib/browser/headless_print_manager.cc b/chromium/headless/lib/browser/headless_print_manager.cc
index 42bd9266fe6..876da578449 100644
--- a/chromium/headless/lib/browser/headless_print_manager.cc
+++ b/chromium/headless/lib/browser/headless_print_manager.cc
@@ -18,8 +18,6 @@
 #include "printing/print_job_constants.h"
 #include "printing/units.h"
 
-DEFINE_WEB_CONTENTS_USER_DATA_KEY(headless::HeadlessPrintManager);
-
 namespace headless {
 
 struct HeadlessPrintManager::FrameDispatchHelper {
diff --git a/chromium/headless/lib/browser/headless_url_request_context_getter.cc b/chromium/headless/lib/browser/headless_url_request_context_getter.cc
index 7555a41b2e6..06502b46f8c 100644
--- a/chromium/headless/lib/browser/headless_url_request_context_getter.cc
+++ b/chromium/headless/lib/browser/headless_url_request_context_getter.cc
@@ -8,7 +8,7 @@
 #include <utility>
 #include <vector>
 
-#include "base/task_scheduler/post_task.h"
+#include "base/task/post_task.h"
 #include "build/build_config.h"
 #include "components/cookie_config/cookie_store_util.h"
 #include "content/public/browser/browser_thread.h"
@@ -137,8 +137,9 @@ HeadlessURLRequestContextGetter::GetURLRequestContext() {
         user_data_path_.Append(FILE_PATH_LITERAL("Cookies")), false, true,
         NULL);
     cookie_config.crypto_delegate = cookie_config::GetCookieCryptoDelegate();
+    // TODO(crbug.com/801910): Hook up logging by passing in a non-null netlog.
     std::unique_ptr<net::CookieStore> cookie_store =
-        CreateCookieStore(cookie_config);
+        CreateCookieStore(cookie_config, nullptr /* netlog*/);
     std::unique_ptr<net::ChannelIDService> channel_id_service =
         std::make_unique<net::ChannelIDService>(
             new net::DefaultChannelIDStore(nullptr));
diff --git a/chromium/headless/lib/browser/headless_web_contents_impl.h b/chromium/headless/lib/browser/headless_web_contents_impl.h
index 7a0bb87a063..2654775b775 100644
--- a/chromium/headless/lib/browser/headless_web_contents_impl.h
+++ b/chromium/headless/lib/browser/headless_web_contents_impl.h
@@ -174,7 +174,7 @@ class HEADLESS_EXPORT HeadlessWebContentsImpl
   // to fix this. See crbug.com/715924
   content::RenderProcessHost* render_process_host_;  // Not owned.
 
-  base::ObserverList<HeadlessWebContents::Observer> observers_;
+  base::ObserverList<HeadlessWebContents::Observer>::Unchecked observers_;
 
   base::WeakPtrFactory<HeadlessWebContentsImpl> weak_ptr_factory_;
 
diff --git a/chromium/headless/lib/browser/protocol/headless_devtools_session.cc b/chromium/headless/lib/browser/protocol/headless_devtools_session.cc
index 9f3cd93a84d..d7cc307449f 100644
--- a/chromium/headless/lib/browser/protocol/headless_devtools_session.cc
+++ b/chromium/headless/lib/browser/protocol/headless_devtools_session.cc
@@ -23,7 +23,6 @@ HeadlessDevToolsSession::HeadlessDevToolsSession(
       agent_host_(agent_host),
       client_(client),
       dispatcher_(std::make_unique<UberDispatcher>(this)) {
-  dispatcher_->setFallThroughForNotFound(true);
   if (agent_host->GetWebContents() &&
       agent_host->GetType() == content::DevToolsAgentHost::kTypePage) {
     AddHandler(std::make_unique<HeadlessHandler>(browser_,
@@ -44,6 +43,29 @@ HeadlessDevToolsSession::~HeadlessDevToolsSession() {
   handlers_.clear();
 }
 
+void HeadlessDevToolsSession::HandleCommand(
+    std::unique_ptr<base::DictionaryValue> command,
+    const std::string& message,
+    content::DevToolsManagerDelegate::NotHandledCallback callback) {
+  if (!browser_) {
+    std::move(callback).Run(std::move(command), message);
+    return;
+  }
+  int call_id;
+  std::string method;
+  std::unique_ptr<protocol::Value> protocolCommand =
+      protocol::toProtocolValue(command.get(), 1000);
+  if (!dispatcher_->parseCommand(protocolCommand.get(), &call_id, &method)) {
+    return;
+  }
+  if (dispatcher_->canDispatch(method)) {
+    pending_commands_[call_id] =
+        std::make_pair(std::move(callback), std::move(command));
+    dispatcher_->dispatch(call_id, method, std::move(protocolCommand), message);
+    return;
+  }
+  std::move(callback).Run(std::move(command), message);
+}
 void HeadlessDevToolsSession::AddHandler(
     std::unique_ptr<protocol::DomainHandler> handler) {
   handler->Wire(dispatcher_.get());
@@ -53,9 +75,18 @@ void HeadlessDevToolsSession::AddHandler(
 void HeadlessDevToolsSession::sendProtocolResponse(
     int call_id,
     std::unique_ptr<Serializable> message) {
+  pending_commands_.erase(call_id);
   client_->DispatchProtocolMessage(agent_host_, message->serialize());
 }
 
+void HeadlessDevToolsSession::fallThrough(int call_id,
+                                          const std::string& method,
+                                          const std::string& message) {
+  PendingCommand command = std::move(pending_commands_[call_id]);
+  pending_commands_.erase(call_id);
+  std::move(command.first).Run(std::move(command.second), message);
+}
+
 void HeadlessDevToolsSession::sendProtocolNotification(
     std::unique_ptr<Serializable> message) {
   client_->DispatchProtocolMessage(agent_host_, message->serialize());
diff --git a/chromium/headless/lib/browser/protocol/headless_devtools_session.h b/chromium/headless/lib/browser/protocol/headless_devtools_session.h
index 28c3cc03d0e..4a28551d14b 100644
--- a/chromium/headless/lib/browser/protocol/headless_devtools_session.h
+++ b/chromium/headless/lib/browser/protocol/headless_devtools_session.h
@@ -7,8 +7,10 @@
 
 #include <memory>
 
+#include "base/values.h"
 #include "base/containers/flat_map.h"
 #include "base/memory/weak_ptr.h"
+#include "content/public/browser/devtools_manager_delegate.h"
 #include "headless/lib/browser/protocol/forward.h"
 #include "headless/lib/browser/protocol/protocol.h"
 
@@ -32,6 +34,11 @@ class HeadlessDevToolsSession : public FrontendChannel {
                           content::DevToolsAgentHostClient* client);
   ~HeadlessDevToolsSession() override;
 
+  void HandleCommand(
+      std::unique_ptr<base::DictionaryValue> command,
+      const std::string& message,
+      content::DevToolsManagerDelegate::NotHandledCallback callback);
+
   UberDispatcher* dispatcher() { return dispatcher_.get(); }
 
  private:
@@ -42,12 +49,19 @@ class HeadlessDevToolsSession : public FrontendChannel {
                             std::unique_ptr<Serializable> message) override;
   void sendProtocolNotification(std::unique_ptr<Serializable> message) override;
   void flushProtocolNotifications() override;
+  void fallThrough(int call_id,
+                   const std::string& method,
+                   const std::string& message) override;
 
   base::WeakPtr<HeadlessBrowserImpl> browser_;
   content::DevToolsAgentHost* const agent_host_;
   content::DevToolsAgentHostClient* const client_;
   std::unique_ptr<UberDispatcher> dispatcher_;
   base::flat_map<std::string, std::unique_ptr<DomainHandler>> handlers_;
+  using PendingCommand =
+      std::pair<content::DevToolsManagerDelegate::NotHandledCallback,
+                std::unique_ptr<base::DictionaryValue>>;
+  base::flat_map<int, PendingCommand> pending_commands_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessDevToolsSession);
 };
diff --git a/chromium/headless/lib/browser/protocol/target_handler.cc b/chromium/headless/lib/browser/protocol/target_handler.cc
index f6e5f9aab1c..b1865d56726 100644
--- a/chromium/headless/lib/browser/protocol/target_handler.cc
+++ b/chromium/headless/lib/browser/protocol/target_handler.cc
@@ -72,45 +72,5 @@ Response TargetHandler::CloseTarget(const std::string& target_id,
   }
   return Response::OK();
 }
-
-Response TargetHandler::CreateBrowserContext(std::string* out_context_id) {
-  auto builder = browser()->CreateBrowserContextBuilder();
-  builder.SetIncognitoMode(true);
-  HeadlessBrowserContext* browser_context = builder.Build();
-
-  *out_context_id = browser_context->Id();
-  return Response::OK();
-}
-
-Response TargetHandler::DisposeBrowserContext(const std::string& context_id) {
-  HeadlessBrowserContext* context =
-      browser()->GetBrowserContextForId(context_id);
-
-  if (!context)
-    return Response::InvalidParams("browserContextId");
-
-  std::vector<HeadlessWebContents*> web_contents = context->GetAllWebContents();
-  while (!web_contents.empty()) {
-    for (auto* wc : web_contents)
-      wc->Close();
-    // Since HeadlessWebContents::Close spawns a nested run loop to await
-    // closing, new web_contents could be opened. We need to re-query pages and
-    // close them too.
-    web_contents = context->GetAllWebContents();
-  }
-  context->Close();
-  return Response::OK();
-}
-
-Response TargetHandler::GetBrowserContexts(
-    std::unique_ptr<protocol::Array<protocol::String>>* browser_context_ids) {
-  *browser_context_ids = std::make_unique<protocol::Array<protocol::String>>();
-  for (auto* context : browser()->GetAllBrowserContexts()) {
-    if (context != browser()->GetDefaultBrowserContext())
-      (*browser_context_ids)->addItem(context->Id());
-  }
-  return Response::OK();
-}
-
 }  // namespace protocol
 }  // namespace headless
diff --git a/chromium/headless/lib/browser/protocol/target_handler.h b/chromium/headless/lib/browser/protocol/target_handler.h
index fa57d8b01c8..c1b1a250491 100644
--- a/chromium/headless/lib/browser/protocol/target_handler.h
+++ b/chromium/headless/lib/browser/protocol/target_handler.h
@@ -27,11 +27,6 @@ class TargetHandler : public DomainHandler, public Target::Backend {
                         std::string* out_target_id) override;
   Response CloseTarget(const std::string& target_id,
                        bool* out_success) override;
-  Response CreateBrowserContext(std::string* out_context_id) override;
-  Response DisposeBrowserContext(const std::string& context_id) override;
-  Response GetBrowserContexts(
-      std::unique_ptr<protocol::Array<protocol::String>>* browser_context_ids)
-      override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TargetHandler);