Headless: remove the impossible API, we can't notify UI objects on the IO thread.

Change-Id: Ifadcbeb60007662da55832c5e20e8c4b9433a0ec
Reviewed-on: https://chromium-review.googlesource.com/1113549
Commit-Queue: Pavel Feldman <pfeldman@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Eric Seckler <eseckler@chromium.org>
Cr-Commit-Position: refs/heads/master@{#570044}

headless/BUILD.gn

@@ -306,10 +306,6 @@ component("headless") {
     "lib/browser/headless_net_log.h",
     "lib/browser/headless_network_conditions.cc",
     "lib/browser/headless_network_conditions.h",
-    "lib/browser/headless_network_delegate.cc",
-    "lib/browser/headless_network_delegate.h",
-    "lib/browser/headless_network_transaction_factory.cc",
-    "lib/browser/headless_network_transaction_factory.h",
     "lib/browser/headless_permission_manager.cc",
     "lib/browser/headless_permission_manager.h",
     "lib/browser/headless_platform_event_source.cc",

headless/lib/browser/headless_browser_context_impl.cc

@@ -83,7 +83,6 @@ HeadlessBrowserContextImpl::HeadlessBrowserContextImpl(
     : browser_(browser),
       context_options_(std::move(context_options)),
       resource_context_(std::make_unique<HeadlessResourceContext>()),
-      should_remove_headers_(true),
       permission_manager_(std::make_unique<HeadlessPermissionManager>(this)) {
   InitWhileIOAllowed();
 }
@@ -92,13 +91,6 @@ HeadlessBrowserContextImpl::~HeadlessBrowserContextImpl() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   NotifyWillBeDestroyed(this);
 
-  // Inform observers that we're going away.
-  {
-    base::AutoLock lock(observers_lock_);
-    for (auto& observer : observers_)
-      observer.OnHeadlessBrowserContextDestruct();
-  }
-
   // Destroy all web contents before shutting down storage partitions.
   web_contents_map_.clear();
 
@@ -362,45 +354,10 @@ const HeadlessBrowserContextOptions* HeadlessBrowserContextImpl::options()
   return context_options_.get();
 }
 
-void HeadlessBrowserContextImpl::SetRemoveHeaders(bool should_remove_headers) {
-  should_remove_headers_ = should_remove_headers;
-}
-
-bool HeadlessBrowserContextImpl::ShouldRemoveHeaders() const {
-  return should_remove_headers_;
-}
-
 const std::string& HeadlessBrowserContextImpl::Id() const {
   return UniqueId();
 }
 
-void HeadlessBrowserContextImpl::AddObserver(Observer* obs) {
-  base::AutoLock lock(observers_lock_);
-  observers_.AddObserver(obs);
-}
-
-void HeadlessBrowserContextImpl::RemoveObserver(Observer* obs) {
-  base::AutoLock lock(observers_lock_);
-  observers_.RemoveObserver(obs);
-}
-
-void HeadlessBrowserContextImpl::NotifyUrlRequestFailed(
-    net::URLRequest* request,
-    int net_error,
-    DevToolsStatus devtools_status) {
-  base::AutoLock lock(observers_lock_);
-  for (auto& observer : observers_)
-    observer.UrlRequestFailed(request, net_error, devtools_status);
-}
-
-void HeadlessBrowserContextImpl::NotifyMetadataForResource(const GURL& url,
-                                                           net::IOBuffer* buf,
-                                                           int buf_len) {
-  base::AutoLock lock(observers_lock_);
-  for (auto& observer : observers_)
-    observer.OnMetadataForResource(url, buf, buf_len);
-}
-
 void HeadlessBrowserContextImpl::SetNetworkConditions(
     HeadlessNetworkConditions conditions) {
   network_conditions_ = conditions;
@@ -512,13 +469,6 @@ HeadlessBrowserContext::Builder::SetOverrideWebPreferencesCallback(
   return *this;
 }
 
-HeadlessBrowserContext::Builder&
-HeadlessBrowserContext::Builder::SetCaptureResourceMetadata(
-    bool capture_resource_metadata) {
-  options_->capture_resource_metadata_ = capture_resource_metadata;
-  return *this;
-}
-
 HeadlessBrowserContext* HeadlessBrowserContext::Builder::Build() {
   if (!mojo_bindings_.empty()) {
     // Unless you know what you're doing it's unsafe to allow http/https for a

headless/lib/browser/headless_browser_context_impl.h

@@ -47,8 +47,6 @@ class HEADLESS_EXPORT HeadlessBrowserContextImpl final
       const std::string& devtools_agent_host_id) override;
   void Close() override;
   const std::string& Id() const override;
-  void AddObserver(Observer* observer) override;
-  void RemoveObserver(Observer* observer) override;
 
   void SetDevToolsFrameToken(int render_process_id,
                              int render_frame_routing_id,
@@ -109,18 +107,6 @@ class HEADLESS_EXPORT HeadlessBrowserContextImpl final
   const base::UnguessableToken* GetDevToolsFrameTokenForFrameTreeNodeId(
       int frame_tree_node_id) const;
 
-  void SetRemoveHeaders(bool should_remove_headers);
-  bool ShouldRemoveHeaders() const;
-
-  // This will be called on the IO thread.
-  void NotifyUrlRequestFailed(net::URLRequest* request,
-                              int net_error,
-                              DevToolsStatus devtools_status);
-
-  void NotifyMetadataForResource(const GURL& url,
-                                 net::IOBuffer* buf,
-                                 int buf_len);
-
   void SetNetworkConditions(HeadlessNetworkConditions conditions);
   HeadlessNetworkConditions GetNetworkConditions() override;
 
@@ -138,9 +124,6 @@ class HEADLESS_EXPORT HeadlessBrowserContextImpl final
   std::unique_ptr<HeadlessResourceContext> resource_context_;
   scoped_refptr<HeadlessURLRequestContextGetter> url_request_getter_;
   base::FilePath path_;
-  base::Lock observers_lock_;
-  base::ObserverList<Observer> observers_;
-  bool should_remove_headers_;
 
   std::unordered_map<std::string, std::unique_ptr<HeadlessWebContents>>
       web_contents_map_;

headless/lib/browser/headless_browser_context_options.cc

@@ -84,11 +84,6 @@ bool HeadlessBrowserContextOptions::block_new_web_contents() const {
                                browser_options_->block_new_web_contents);
 }
 
-bool HeadlessBrowserContextOptions::capture_resource_metadata() const {
-  return ReturnOverriddenValue(capture_resource_metadata_,
-                               browser_options_->capture_resource_metadata);
-}
-
 bool HeadlessBrowserContextOptions::allow_cookies() const {
   return ReturnOverriddenValue(allow_cookies_, browser_options_->allow_cookies);
 }

headless/lib/browser/headless_browser_context_options.h

@@ -51,9 +51,6 @@ class HeadlessBrowserContextOptions {
   // See HeadlessBrowser::Options::block_new_web_contents.
   bool block_new_web_contents() const;
 
-  // See HeadlessBrowser::Options::capture_resource_metadata.
-  bool capture_resource_metadata() const;
-
   bool allow_cookies() const;
 
   // See HeadlessBrowser::Options::font_render_hinting.
@@ -90,7 +87,6 @@ class HeadlessBrowserContextOptions {
   base::Optional<bool> allow_cookies_;
   base::Optional<base::RepeatingCallback<void(WebPreferences*)>>
       override_web_preferences_callback_;
-  base::Optional<bool> capture_resource_metadata_;
 
   ProtocolHandlerMap protocol_handlers_;
 

headless/lib/browser/headless_network_delegate.cc

-// Copyright 2017 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_network_delegate.h"
-
-#include "content/public/browser/resource_request_info.h"
-#include "headless/lib/browser/headless_browser_context_impl.h"
-#include "net/base/net_errors.h"
-#include "net/http/http_request_headers.h"
-#include "net/url_request/url_request_context.h"
-#include "url/url_constants.h"
-
-#include "net/url_request/url_request.h"
-
-namespace headless {
-
-HeadlessNetworkDelegate::HeadlessNetworkDelegate(
-    HeadlessBrowserContextImpl* headless_browser_context)
-    : headless_browser_context_(headless_browser_context) {
-  base::AutoLock lock(lock_);
-  if (headless_browser_context_)
-    headless_browser_context_->AddObserver(this);
-}
-
-HeadlessNetworkDelegate::~HeadlessNetworkDelegate() {
-  base::AutoLock lock(lock_);
-  if (headless_browser_context_)
-    headless_browser_context_->RemoveObserver(this);
-}
-
-int HeadlessNetworkDelegate::OnBeforeURLRequest(
-    net::URLRequest* request,
-    net::CompletionOnceCallback callback,
-    GURL* new_url) {
-  return net::OK;
-}
-
-void HeadlessNetworkDelegate::OnCompleted(net::URLRequest* request,
-                                          bool started,
-                                          int net_error) {
-  base::AutoLock lock(lock_);
-  if (!headless_browser_context_)
-    return;
-
-  const content::ResourceRequestInfo* resource_request_info =
-      content::ResourceRequestInfo::ForRequest(request);
-  if (!resource_request_info)
-    return;
-
-  DevToolsStatus devtools_status = resource_request_info->GetDevToolsStatus();
-  if (devtools_status != DevToolsStatus::kNotCanceled || net_error != net::OK) {
-    headless_browser_context_->NotifyUrlRequestFailed(request, net_error,
-                                                      devtools_status);
-  }
-}
-
-bool HeadlessNetworkDelegate::OnCanAccessFile(
-    const net::URLRequest& request,
-    const base::FilePath& original_path,
-    const base::FilePath& absolute_path) const {
-  return true;
-}
-
-void HeadlessNetworkDelegate::OnHeadlessBrowserContextDestruct() {
-  base::AutoLock lock(lock_);
-  headless_browser_context_ = nullptr;
-}
-
-}  // namespace headless

headless/lib/browser/headless_network_delegate.h

-// Copyright 2017 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.
-
-#ifndef HEADLESS_LIB_BROWSER_HEADLESS_NETWORK_DELEGATE_H_
-#define HEADLESS_LIB_BROWSER_HEADLESS_NETWORK_DELEGATE_H_
-
-#include "base/macros.h"
-
-#include "base/synchronization/lock.h"
-#include "headless/public/headless_browser_context.h"
-#include "net/base/network_delegate_impl.h"
-
-namespace headless {
-class HeadlessBrowserContextImpl;
-
-// We use the HeadlessNetworkDelegate to remove DevTools request headers before
-// requests are actually fetched and for reporting failed network requests.
-class HeadlessNetworkDelegate : public net::NetworkDelegateImpl,
-                                public HeadlessBrowserContext::Observer {
- public:
-  explicit HeadlessNetworkDelegate(
-      HeadlessBrowserContextImpl* headless_browser_context);
-  ~HeadlessNetworkDelegate() override;
-
- private:
-  // net::NetworkDelegateImpl implementation:
-  int OnBeforeURLRequest(net::URLRequest* request,
-                         net::CompletionOnceCallback callback,
-                         GURL* new_url) override;
-
-  void OnCompleted(net::URLRequest* request,
-                   bool started,
-                   int net_error) override;
-
-  bool OnCanAccessFile(const net::URLRequest& request,
-                       const base::FilePath& original_path,
-                       const base::FilePath& absolute_path) const override;
-
-  // HeadlessBrowserContext::Observer implementation:
-  void OnHeadlessBrowserContextDestruct() override;
-
-  base::Lock lock_;  // Protects |headless_browser_context_|.
-  HeadlessBrowserContextImpl* headless_browser_context_;  // Not owned.
-
-  DISALLOW_COPY_AND_ASSIGN(HeadlessNetworkDelegate);
-};
-
-}  // namespace headless
-
-#endif  // HEADLESS_LIB_BROWSER_HEADLESS_NETWORK_DELEGATE_H_

headless/lib/browser/headless_network_transaction_factory.cc

-// Copyright 2018 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_network_transaction_factory.h"
-
-#include "base/callback_helpers.h"
-#include "base/logging.h"
-#include "headless/lib/browser/headless_browser_context_impl.h"
-#include "net/base/completion_once_callback.h"
-#include "net/http/http_cache_writers.h"
-#include "net/http/http_transaction.h"
-
-namespace headless {
-
-class HeadlessCacheBackendFactory : public net::HttpCache::BackendFactory {
- public:
-  HeadlessCacheBackendFactory() {}
-  ~HeadlessCacheBackendFactory() override {}
-
-  int CreateBackend(net::NetLog* net_log,
-                    std::unique_ptr<disk_cache::Backend>* backend,
-                    net::CompletionOnceCallback callback) override {
-    return net::OK;
-  }
-};
-
-class HeadlessHttpCache : public net::HttpCache {
- public:
-  HeadlessHttpCache(net::HttpNetworkSession* session,
-                    HeadlessBrowserContextImpl* headless_browser_context)
-      : net::HttpCache(session,
-                       std::make_unique<HeadlessCacheBackendFactory>(),
-                       true /* is_main_cache */),
-        headless_browser_context_(headless_browser_context) {}
-
-  ~HeadlessHttpCache() override {}
-
-  void WriteMetadata(const GURL& url,
-                     net::RequestPriority priority,
-                     base::Time expected_response_time,
-                     net::IOBuffer* buf,
-                     int buf_len) override {
-    headless_browser_context_->NotifyMetadataForResource(url, buf, buf_len);
-  }
-
- private:
-  HeadlessBrowserContextImpl* headless_browser_context_;  // NOT OWNED
-};
-
-HeadlessNetworkTransactionFactory::HeadlessNetworkTransactionFactory(
-    net::HttpNetworkSession* session,
-    HeadlessBrowserContextImpl* headless_browser_context)
-    : session_(session),
-      http_cache_(new HeadlessHttpCache(session, headless_browser_context)) {}
-
-HeadlessNetworkTransactionFactory::~HeadlessNetworkTransactionFactory() {}
-
-// static
-std::unique_ptr<net::HttpTransactionFactory>
-HeadlessNetworkTransactionFactory::Create(
-    HeadlessBrowserContextImpl* headless_browser_context,
-    net::HttpNetworkSession* session) {
-  return std::make_unique<HeadlessNetworkTransactionFactory>(
-      session, headless_browser_context);
-}
-
-int HeadlessNetworkTransactionFactory::CreateTransaction(
-    net::RequestPriority priority,
-    std::unique_ptr<net::HttpTransaction>* trans) {
-  return http_cache_->CreateTransaction(priority, trans);
-}
-
-net::HttpCache* HeadlessNetworkTransactionFactory::GetCache() {
-  return http_cache_.get();
-}
-
-net::HttpNetworkSession* HeadlessNetworkTransactionFactory::GetSession() {
-  return session_;
-}
-
-}  // namespace headless

headless/lib/browser/headless_network_transaction_factory.h

-// Copyright 2018 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.
-
-#ifndef HEADLESS_LIB_BROWSER_HEADLESS_NETWORK_TRANSACTION_FACTORY_H_
-#define HEADLESS_LIB_BROWSER_HEADLESS_NETWORK_TRANSACTION_FACTORY_H_
-
-#include "base/macros.h"
-#include "net/http/http_cache.h"
-#include "net/http/http_transaction_factory.h"
-
-namespace headless {
-
-class HeadlessBrowserContextImpl;
-
-// This class exists purely to let headless capture resource metadata.
-// In the cases where this used, the headless embedder will have its own
-// protocol handler.
-class HeadlessNetworkTransactionFactory : public net::HttpTransactionFactory {
- public:
-  HeadlessNetworkTransactionFactory(
-      net::HttpNetworkSession* session,
-      HeadlessBrowserContextImpl* headless_browser_context);
-
-  ~HeadlessNetworkTransactionFactory() override;
-
-  static std::unique_ptr<net::HttpTransactionFactory> Create(
-      HeadlessBrowserContextImpl* headless_browser_context,
-      net::HttpNetworkSession* session);
-
-  // Creates a HttpTransaction object. On success, saves the new
-  // transaction to |*trans| and returns OK.
-  int CreateTransaction(net::RequestPriority priority,
-                        std::unique_ptr<net::HttpTransaction>* trans) override;
-
-  // Returns the associated cache if any (may be NULL).
-  net::HttpCache* GetCache() override;
-
-  // Returns the associated HttpNetworkSession used by new transactions.
-  net::HttpNetworkSession* GetSession() override;
-
- private:
-  net::HttpNetworkSession* const session_;  // NOT OWNED
-
-  std::unique_ptr<net::HttpCache> http_cache_;
-};
-
-}  // namespace headless
-
-#endif  // HEADLESS_LIB_BROWSER_HEADLESS_NETWORK_TRANSACTION_FACTORY_H_

headless/lib/browser/headless_url_request_context_getter.h

@@ -30,9 +30,7 @@ namespace headless {
 class HeadlessBrowserContextOptions;
 class HeadlessBrowserContextImpl;
 
-class HeadlessURLRequestContextGetter
-    : public net::URLRequestContextGetter,
-      public HeadlessBrowserContext::Observer {
+class HeadlessURLRequestContextGetter : public net::URLRequestContextGetter {
  public:
   HeadlessURLRequestContextGetter(
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
@@ -50,9 +48,6 @@ class HeadlessURLRequestContextGetter
 
   net::HostResolver* host_resolver() const;
 
-  // HeadlessBrowserContext::Observer implementation:
-  void OnHeadlessBrowserContextDestruct() override;
-
   void NotifyContextShuttingDown();
 
  protected:
@@ -74,12 +69,8 @@ class HeadlessURLRequestContextGetter
   content::ProtocolHandlerMap protocol_handlers_;
   content::URLRequestInterceptorScopedVector request_interceptors_;
   net::NetLog* net_log_;  // Not owned
-  bool capture_resource_metadata_;
   net::HttpAuthPreferences prefs_;
-
-  base::Lock lock_;  // Protects |headless_browser_context_|.
-  HeadlessBrowserContextImpl* headless_browser_context_;  // Not owned.
-
+  base::FilePath user_data_path_;
   bool shut_down_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessURLRequestContextGetter);

headless/lib/headless_devtools_client_browsertest.cc

@@ -1293,113 +1293,7 @@ class DomTreeExtractionBrowserTest : public HeadlessAsyncDevTooledBrowserTest,
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(DomTreeExtractionBrowserTest);
 
-class UrlRequestFailedTest : public HeadlessAsyncDevTooledBrowserTest,
-                             public HeadlessBrowserContext::Observer,
-                             public network::ExperimentalObserver,
-                             public page::Observer {
- public:
-  void RunDevTooledTest() override {
-    EXPECT_TRUE(embedded_test_server()->Start());
-    devtools_client_->GetNetwork()->GetExperimental()->AddObserver(this);
-    devtools_client_->GetNetwork()->Enable();
-
-    std::unique_ptr<headless::network::RequestPattern> match_all =
-        headless::network::RequestPattern::Builder().SetUrlPattern("*").Build();
-    std::vector<std::unique_ptr<headless::network::RequestPattern>> patterns;
-    patterns.push_back(std::move(match_all));
-    devtools_client_->GetNetwork()->GetExperimental()->SetRequestInterception(
-        network::SetRequestInterceptionParams::Builder()
-            .SetPatterns(std::move(patterns))
-            .Build());
-
-    browser_context_->AddObserver(this);
-
-    devtools_client_->GetPage()->AddObserver(this);
-
-    base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
-    devtools_client_->GetPage()->Enable(run_loop.QuitClosure());
-    run_loop.Run();
-
-    devtools_client_->GetPage()->Navigate(
-        embedded_test_server()->GetURL("/resource_cancel_test.html").spec());
-  }
-
-  bool ShouldCancel(const std::string& url) {
-    if (EndsWith(url, "/iframe.html", base::CompareCase::INSENSITIVE_ASCII))
-      return true;
-
-    if (EndsWith(url, "/test.jpg", base::CompareCase::INSENSITIVE_ASCII))
-      return true;
-
-    return false;
-  }
-
-  void OnRequestIntercepted(
-      const network::RequestInterceptedParams& params) override {
-    urls_seen_.push_back(GURL(params.GetRequest()->GetUrl()).ExtractFileName());
-    auto continue_intercept_params =
-        network::ContinueInterceptedRequestParams::Builder()
-            .SetInterceptionId(params.GetInterceptionId())
-            .Build();
-    if (ShouldCancel(params.GetRequest()->GetUrl()))
-      continue_intercept_params->SetErrorReason(GetErrorReason());
-
-    devtools_client_->GetNetwork()
-        ->GetExperimental()
-        ->ContinueInterceptedRequest(std::move(continue_intercept_params));
-  }
-
-  void OnLoadEventFired(const page::LoadEventFiredParams&) override {
-    browser_context_->RemoveObserver(this);
-
-    base::AutoLock lock(lock_);
-    EXPECT_THAT(urls_that_failed_to_load_,
-                ElementsAre("test.jpg", "iframe.html"));
-    EXPECT_THAT(
-        urls_seen_,
-        ElementsAre("resource_cancel_test.html", "dom_tree_test.css",
-                    "test.jpg", "iframe.html", "iframe2.html", "Ahem.ttf"));
-    FinishAsynchronousTest();
-  }
-
-  void UrlRequestFailed(net::URLRequest* request,
-                        int net_error,
-                        DevToolsStatus devtools_status) override {
-    base::AutoLock lock(lock_);
-    urls_that_failed_to_load_.push_back(request->url().ExtractFileName());
-    EXPECT_TRUE(devtools_status != DevToolsStatus::kNotCanceled);
-  }
-
-  virtual network::ErrorReason GetErrorReason() = 0;
-
- private:
-  base::Lock lock_;
-  std::vector<std::string> urls_seen_;
-  std::vector<std::string> urls_that_failed_to_load_;
-};
-
-class UrlRequestFailedTest_Failed : public UrlRequestFailedTest {
- public:
-  network::ErrorReason GetErrorReason() override {
-    return network::ErrorReason::FAILED;
-  }
-};
-
-HEADLESS_ASYNC_DEVTOOLED_TEST_F(UrlRequestFailedTest_Failed);
-
-class UrlRequestFailedTest_Abort : public UrlRequestFailedTest {
- public:
-  network::ErrorReason GetErrorReason() override {
-    return network::ErrorReason::ABORTED;
-  }
-};
-
-HEADLESS_ASYNC_DEVTOOLED_TEST_F(UrlRequestFailedTest_Abort);
-
-// A test for recording failed URL loading events, much like
-// UrlRequestFailedTest{_Failed,Abort} above, but without overriding
-// HeadlessBrowserContext::Observer. Instead, this feature uses
-// network observation and works exactly and only for
+// This feature uses network observation and works exactly and only for
 // network::ErrorReason::BLOCKED_BY_CLIENT modifications that are initiated
 // via network::ExperimentalObserver.
 class BlockedByClient_NetworkObserver_Test

headless/public/headless_browser.cc

@@ -188,11 +188,6 @@ Builder& Builder::SetCrashReporterEnabled(bool enabled) {
   return *this;
 }
 
-Builder& Builder::SetCaptureResourceMetadata(bool capture_resource_metadata) {
-  options_.capture_resource_metadata = capture_resource_metadata;
-  return *this;
-}
-
 Builder& Builder::SetCrashDumpsDir(const base::FilePath& dir) {
   options_.crash_dumps_dir = dir;
   return *this;

headless/public/headless_browser.h

@@ -193,12 +193,6 @@ struct HEADLESS_EXPORT HeadlessBrowser::Options {
   // Whether or not all sites should have a dedicated process.
   bool site_per_process = false;
 
-  // Whether or not the net::HttpCache should be replaced with a custom one that
-  // intercepts metadata writes which are surfaced via
-  // HeadlessBrowserContext::Observer:OnMetadataForResource. The custom cache
-  // blacks holes all writes.
-  bool capture_resource_metadata = false;
-
   // Set a callback that is invoked to override WebPreferences for RenderViews
   // created within the HeadlessBrowser. Called whenever the WebPreferences of a
   // RenderView change. Executed on the browser main thread.
@@ -280,7 +274,6 @@ class HEADLESS_EXPORT HeadlessBrowser::Options::Builder {
   Builder& SetOverrideWebPreferencesCallback(
       base::RepeatingCallback<void(WebPreferences*)> callback);
   Builder& SetCrashReporterEnabled(bool enabled);
-  Builder& SetCaptureResourceMetadata(bool capture_resource_metadata);
   Builder& SetCrashDumpsDir(const base::FilePath& dir);
   Builder& SetFontRenderHinting(
       gfx::FontRenderParams::Hinting font_render_hinting);

headless/public/headless_browser_context.h

@@ -26,10 +26,6 @@ namespace base {
 class FilePath;
 }
 
-namespace net {
-class IOBuffer;
-};
-
 namespace headless {
 class HeadlessBrowserImpl;
 class HeadlessBrowserContextOptions;
@@ -46,7 +42,6 @@ using content::ProtocolHandlerMap;
 // When browser context is deleted, all associated web contents are closed.
 class HEADLESS_EXPORT HeadlessBrowserContext {
  public:
-  class Observer;
   class Builder;
 
   virtual ~HeadlessBrowserContext() {}
@@ -72,9 +67,6 @@ class HEADLESS_EXPORT HeadlessBrowserContext {
   // GUID for this browser context.
   virtual const std::string& Id() const = 0;
 
-  virtual void AddObserver(Observer* observer) = 0;
-  virtual void RemoveObserver(Observer* observer) = 0;
-
   virtual HeadlessNetworkConditions GetNetworkConditions() = 0;
 
   // TODO(skyostil): Allow saving and restoring contexts (crbug.com/617931).
@@ -86,28 +78,6 @@ class HEADLESS_EXPORT HeadlessBrowserContext {
   DISALLOW_COPY_AND_ASSIGN(HeadlessBrowserContext);
 };
 
-class HEADLESS_EXPORT HeadlessBrowserContext::Observer {
- public:
-
-  // Indicates that a network request failed or was canceled. This will be
-  // delivered on the IO thread.
-  virtual void UrlRequestFailed(net::URLRequest* request,
-                                int net_error,
-                                DevToolsStatus devtools_status) {}
-
-  // Called when metadata for a resource (e.g. v8 code cache) has been sent by a
-  // renderer.
-  virtual void OnMetadataForResource(const GURL& url,
-                                     net::IOBuffer* buf,
-                                     int buf_len) {}
-
-  // Indicates the HeadlessBrowserContext is about to be deleted.
-  virtual void OnHeadlessBrowserContextDestruct() {}
-
- protected:
-  virtual ~Observer() {}
-};
-
 class HEADLESS_EXPORT HeadlessBrowserContext::Builder {
  public:
   Builder(Builder&&);
@@ -146,7 +116,6 @@ class HEADLESS_EXPORT HeadlessBrowserContext::Builder {
   Builder& SetAllowCookies(bool incognito_mode);
   Builder& SetOverrideWebPreferencesCallback(
       base::RepeatingCallback<void(WebPreferences*)> callback);
-  Builder& SetCaptureResourceMetadata(bool capture_resource_metadata);
 
   HeadlessBrowserContext* Build();
 

headless/test/headless_js_bindings_browsertest.cc

@@ -300,68 +300,4 @@ class SimpleEventJsBindingsTest : public HeadlessJsBindingsTest {
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(SimpleEventJsBindingsTest);
 
-/*
- * Like SimpleCommandJsBindingsTest except it's run twice. On the first run
- * metadata is produced by v8 for http://test.com/bindings.js. On the second run
- * the metadata is used used leading to substantially faster execution time.
- */
-class CachedJsBindingsTest : public HeadlessJsBindingsTest,
-                             public HeadlessBrowserContext::Observer {
- public:
-  void CustomizeHeadlessBrowserContext(
-      HeadlessBrowserContext::Builder& builder) override {
-    builder.SetCaptureResourceMetadata(true);
-    builder.SetOverrideWebPreferencesCallback(base::BindRepeating(
-        &CachedJsBindingsTest::OverrideWebPreferences, base::Unretained(this)));
-    HeadlessJsBindingsTest::CustomizeHeadlessBrowserContext(builder);
-  }
-
-  void OverrideWebPreferences(WebPreferences* preferences) {
-    // Request eager code compilation.
-    preferences->v8_cache_options =
-        content::V8_CACHE_OPTIONS_FULLCODE_WITHOUT_HEAT_CHECK;
-  }
-
-  void RunDevTooledTest() override {
-    browser_context_->AddObserver(this);
-    HeadlessJsBindingsTest::RunDevTooledTest();
-  }
-
-  void RunJsBindingsTest() override {
-    devtools_client_->GetRuntime()->Evaluate(
-        "new chromium.BindingsTest().evalOneAddOne();",
-        base::BindRepeating(&HeadlessJsBindingsTest::FailOnJsEvaluateException,
-                            base::Unretained(this)));
-  }
-
-  void OnResult(const std::string& result) override {
-    EXPECT_EQ("2", result);
-
-    if (first_result) {
-      devtools_client_->GetPage()->Reload();
-    } else {
-      EXPECT_TRUE(metadata_received_);
-      FinishAsynchronousTest();
-    }
-    first_result = false;
-  }
-
-  void OnMetadataForResource(const GURL& url,
-                             net::IOBuffer* buf,
-                             int buf_len) override {
-    ASSERT_FALSE(metadata_received_);
-    metadata_received_ = true;
-
-    scoped_refptr<net::IOBufferWithSize> metadata(
-        new net::IOBufferWithSize(buf_len));
-    memcpy(metadata->data(), buf->data(), buf_len);
-    http_handler_->SetResponseMetadata(url.spec(), metadata);
-  }
-
-  bool metadata_received_ = false;
-  bool first_result = true;
-};
-
-HEADLESS_ASYNC_DEVTOOLED_TEST_F(CachedJsBindingsTest);
-
 }  // namespace headless

headless/test/headless_render_test.cc

@@ -337,15 +337,6 @@ gfx::Size HeadlessRenderTest::GetEmulatedWindowSize() {
   return gfx::Size(800, 600);
 }
 
-void HeadlessRenderTest::UrlRequestFailed(net::URLRequest* request,
-                                          int net_error,
-                                          DevToolsStatus devtools_status) {
-  if (devtools_status != DevToolsStatus::kNotCanceled)
-    return;
-  ADD_FAILURE() << "Network request failed: " << net_error << " for "
-                << request->url().spec();
-}
-
 void HeadlessRenderTest::OnLoadEventFired(const page::LoadEventFiredParams&) {
   CHECK_NE(INIT, state_);
   if (state_ == LOADING || state_ == STARTING) {

headless/test/headless_render_test.h

@@ -34,7 +34,6 @@ class GetSnapshotResult;
 
 // Base class for tests that render a particular page and verify the output.
 class HeadlessRenderTest : public HeadlessAsyncDevTooledBrowserTest,
-                           public HeadlessBrowserContext::Observer,
                            public page::ExperimentalObserver,
                            public runtime::ExperimentalObserver,
                            public TestInMemoryProtocolHandler::RequestDeferrer {
@@ -119,11 +118,6 @@ class HeadlessRenderTest : public HeadlessAsyncDevTooledBrowserTest,
   void PostRunAsynchronousTest() override;
   ProtocolHandlerMap GetProtocolHandlers() override;
 
-  // HeadlessBrowserContext::Observer
-  void UrlRequestFailed(net::URLRequest* request,
-                        int net_error,
-                        DevToolsStatus devtools_status) override;
-
   // page::ExperimentalObserver implementation:
   void OnLoadEventFired(const page::LoadEventFiredParams& params) override;
   void OnFrameStartedLoading(