[DevTools] Remove Browser domain, switch clients to Target.

headless/lib/headless_devtools_client_browsertest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/json/json_reader.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
-#include "headless/public/domains/browser.h"
 #include "headless/public/domains/emulation.h"
 #include "headless/public/domains/network.h"
 #include "headless/public/domains/page.h"
 #include "headless/public/domains/runtime.h"
+#include "headless/public/domains/target.h"
 #include "headless/public/headless_browser.h"
 #include "headless/public/headless_devtools_client.h"
 #include "headless/public/headless_devtools_target.h"
 #include "headless/test/headless_browser_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 #define EXPECT_SIZE_EQ(expected, actual)               \
   do {                                                 \
     EXPECT_EQ((expected).width(), (actual).width());   \
@@ skipping 184 matching lines @@
         page::ReloadParams::Builder().Build(),
         base::Bind(&HeadlessDevToolsClientExperimentalTest::OnReloadStarted,
                    base::Unretained(this)));
   }
 
   void OnReloadStarted() { FinishAsynchronousTest(); }
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsClientExperimentalTest);
 
-class BrowserDomainCreateAndDeletePageTest
+class TargetDomainCreateAndDeletePageTest
     : public HeadlessAsyncDevTooledBrowserTest {
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
 
     EXPECT_EQ(1u, GetAllWebContents(browser()).size());
 
-    devtools_client_->GetBrowser()->GetExperimental()->CreateTarget(
-        browser::CreateTargetParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->CreateTarget(
+        target::CreateTargetParams::Builder()
             .SetUrl(embedded_test_server()->GetURL("/hello.html").spec())
             .SetWidth(1)
             .SetHeight(1)
             .Build(),
-        base::Bind(&BrowserDomainCreateAndDeletePageTest::OnCreateTargetResult,
+        base::Bind(&TargetDomainCreateAndDeletePageTest::OnCreateTargetResult,
                    base::Unretained(this)));
   }
 
   void OnCreateTargetResult(
-      std::unique_ptr<browser::CreateTargetResult> result) {
+      std::unique_ptr<target::CreateTargetResult> result) {
     EXPECT_EQ(2u, GetAllWebContents(browser()).size());
 
     HeadlessWebContentsImpl* contents = HeadlessWebContentsImpl::From(
         browser()->GetWebContentsForDevToolsAgentHostId(result->GetTargetId()));
     EXPECT_SIZE_EQ(gfx::Size(1, 1), contents->web_contents()
                                         ->GetRenderWidgetHostView()
                                         ->GetViewBounds()
                                         .size());
 
-    devtools_client_->GetBrowser()->GetExperimental()->CloseTarget(
-        browser::CloseTargetParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->CloseTarget(
+        target::CloseTargetParams::Builder()
             .SetTargetId(result->GetTargetId())
             .Build(),
-        base::Bind(&BrowserDomainCreateAndDeletePageTest::OnCloseTargetResult,
+        base::Bind(&TargetDomainCreateAndDeletePageTest::OnCloseTargetResult,
                    base::Unretained(this)));
   }
 
-  void OnCloseTargetResult(std::unique_ptr<browser::CloseTargetResult> result) {
+  void OnCloseTargetResult(std::unique_ptr<target::CloseTargetResult> result) {
     EXPECT_TRUE(result->GetSuccess());
     EXPECT_EQ(1u, GetAllWebContents(browser()).size());
     FinishAsynchronousTest();
   }
 };
 
-HEADLESS_ASYNC_DEVTOOLED_TEST_F(BrowserDomainCreateAndDeletePageTest);
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateAndDeletePageTest);
 
-class BrowserDomainCreateAndDeleteBrowserContextTest
+class TargetDomainCreateAndDeleteBrowserContextTest
     : public HeadlessAsyncDevTooledBrowserTest {
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
 
     EXPECT_EQ(1u, GetAllWebContents(browser()).size());
 
-    devtools_client_->GetBrowser()->GetExperimental()->CreateBrowserContext(
-        browser::CreateBrowserContextParams::Builder().Build(),
-        base::Bind(&BrowserDomainCreateAndDeleteBrowserContextTest::
+    devtools_client_->GetTarget()->GetExperimental()->CreateBrowserContext(
+        target::CreateBrowserContextParams::Builder().Build(),
+        base::Bind(&TargetDomainCreateAndDeleteBrowserContextTest::
                        OnCreateContextResult,
                    base::Unretained(this)));
   }
 
   void OnCreateContextResult(
-      std::unique_ptr<browser::CreateBrowserContextResult> result) {
+      std::unique_ptr<target::CreateBrowserContextResult> result) {
     browser_context_id_ = result->GetBrowserContextId();
 
-    devtools_client_->GetBrowser()->GetExperimental()->CreateTarget(
-        browser::CreateTargetParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->CreateTarget(
+        target::CreateTargetParams::Builder()
             .SetUrl(embedded_test_server()->GetURL("/hello.html").spec())
             .SetBrowserContextId(result->GetBrowserContextId())
             .SetWidth(1)
             .SetHeight(1)
             .Build(),
-        base::Bind(&BrowserDomainCreateAndDeleteBrowserContextTest::
+        base::Bind(&TargetDomainCreateAndDeleteBrowserContextTest::
                        OnCreateTargetResult,
                    base::Unretained(this)));
   }
 
   void OnCreateTargetResult(
-      std::unique_ptr<browser::CreateTargetResult> result) {
+      std::unique_ptr<target::CreateTargetResult> result) {
     EXPECT_EQ(2u, GetAllWebContents(browser()).size());
 
-    devtools_client_->GetBrowser()->GetExperimental()->CloseTarget(
-        browser::CloseTargetParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->CloseTarget(
+        target::CloseTargetParams::Builder()
             .SetTargetId(result->GetTargetId())
             .Build(),
-        base::Bind(&BrowserDomainCreateAndDeleteBrowserContextTest::
+        base::Bind(&TargetDomainCreateAndDeleteBrowserContextTest::
                        OnCloseTargetResult,
                    base::Unretained(this)));
   }
 
-  void OnCloseTargetResult(std::unique_ptr<browser::CloseTargetResult> result) {
+  void OnCloseTargetResult(std::unique_ptr<target::CloseTargetResult> result) {
     EXPECT_EQ(1u, GetAllWebContents(browser()).size());
     EXPECT_TRUE(result->GetSuccess());
 
-    devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext(
-        browser::DisposeBrowserContextParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->DisposeBrowserContext(
+        target::DisposeBrowserContextParams::Builder()
             .SetBrowserContextId(browser_context_id_)
             .Build(),
-        base::Bind(&BrowserDomainCreateAndDeleteBrowserContextTest::
+        base::Bind(&TargetDomainCreateAndDeleteBrowserContextTest::
                        OnDisposeBrowserContextResult,
                    base::Unretained(this)));
   }
 
   void OnDisposeBrowserContextResult(
-      std::unique_ptr<browser::DisposeBrowserContextResult> result) {
+      std::unique_ptr<target::DisposeBrowserContextResult> result) {
     EXPECT_TRUE(result->GetSuccess());
     FinishAsynchronousTest();
   }
 
  private:
   std::string browser_context_id_;
 };
 
-HEADLESS_ASYNC_DEVTOOLED_TEST_F(BrowserDomainCreateAndDeleteBrowserContextTest);
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateAndDeleteBrowserContextTest);
 
-class BrowserDomainDisposeContextFailsIfInUse
+class TargetDomainDisposeContextFailsIfInUse
     : public HeadlessAsyncDevTooledBrowserTest {
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
 
     EXPECT_EQ(1u, GetAllWebContents(browser()).size());
-    devtools_client_->GetBrowser()->GetExperimental()->CreateBrowserContext(
-        browser::CreateBrowserContextParams::Builder().Build(),
-        base::Bind(&BrowserDomainDisposeContextFailsIfInUse::OnContextCreated,
+    devtools_client_->GetTarget()->GetExperimental()->CreateBrowserContext(
+        target::CreateBrowserContextParams::Builder().Build(),
+        base::Bind(&TargetDomainDisposeContextFailsIfInUse::OnContextCreated,
                    base::Unretained(this)));
   }
 
   void OnContextCreated(
-      std::unique_ptr<browser::CreateBrowserContextResult> result) {
+      std::unique_ptr<target::CreateBrowserContextResult> result) {
     context_id_ = result->GetBrowserContextId();
 
-    devtools_client_->GetBrowser()->GetExperimental()->CreateTarget(
-        browser::CreateTargetParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->CreateTarget(
+        target::CreateTargetParams::Builder()
             .SetUrl(embedded_test_server()->GetURL("/hello.html").spec())
             .SetBrowserContextId(context_id_)
             .Build(),
         base::Bind(
-            &BrowserDomainDisposeContextFailsIfInUse::OnCreateTargetResult,
+            &TargetDomainDisposeContextFailsIfInUse::OnCreateTargetResult,
             base::Unretained(this)));
   }
 
   void OnCreateTargetResult(
-      std::unique_ptr<browser::CreateTargetResult> result) {
+      std::unique_ptr<target::CreateTargetResult> result) {
     page_id_ = result->GetTargetId();
 
-    devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext(
-        browser::DisposeBrowserContextParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->DisposeBrowserContext(
+        target::DisposeBrowserContextParams::Builder()
             .SetBrowserContextId(context_id_)
             .Build(),
-        base::Bind(&BrowserDomainDisposeContextFailsIfInUse::
+        base::Bind(&TargetDomainDisposeContextFailsIfInUse::
                        OnDisposeBrowserContextResult,
                    base::Unretained(this)));
   }
 
   void OnDisposeBrowserContextResult(
-      std::unique_ptr<browser::DisposeBrowserContextResult> result) {
+      std::unique_ptr<target::DisposeBrowserContextResult> result) {
     EXPECT_FALSE(result->GetSuccess());
 
     // Close the page and try again.
-    devtools_client_->GetBrowser()->GetExperimental()->CloseTarget(
-        browser::CloseTargetParams::Builder().SetTargetId(page_id_).Build(),
+    devtools_client_->GetTarget()->GetExperimental()->CloseTarget(
+        target::CloseTargetParams::Builder().SetTargetId(page_id_).Build(),
         base::Bind(
-            &BrowserDomainDisposeContextFailsIfInUse::OnCloseTargetResult,
+            &TargetDomainDisposeContextFailsIfInUse::OnCloseTargetResult,
             base::Unretained(this)));
   }
 
-  void OnCloseTargetResult(std::unique_ptr<browser::CloseTargetResult> result) {
+  void OnCloseTargetResult(std::unique_ptr<target::CloseTargetResult> result) {
     EXPECT_TRUE(result->GetSuccess());
 
-    devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext(
-        browser::DisposeBrowserContextParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->DisposeBrowserContext(
+        target::DisposeBrowserContextParams::Builder()
             .SetBrowserContextId(context_id_)
             .Build(),
-        base::Bind(&BrowserDomainDisposeContextFailsIfInUse::
+        base::Bind(&TargetDomainDisposeContextFailsIfInUse::
                        OnDisposeBrowserContextResult2,
                    base::Unretained(this)));
   }
 
   void OnDisposeBrowserContextResult2(
-      std::unique_ptr<browser::DisposeBrowserContextResult> result) {
+      std::unique_ptr<target::DisposeBrowserContextResult> result) {
     EXPECT_TRUE(result->GetSuccess());
     FinishAsynchronousTest();
   }
 
  private:
   std::string context_id_;
   std::string page_id_;
 };
 
-HEADLESS_ASYNC_DEVTOOLED_TEST_F(BrowserDomainDisposeContextFailsIfInUse);
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainDisposeContextFailsIfInUse);
 
-class BrowserDomainCreateTwoContexts : public HeadlessAsyncDevTooledBrowserTest,
-                                       public browser::ExperimentalObserver {
+class TargetDomainCreateTwoContexts : public HeadlessAsyncDevTooledBrowserTest,
+                                      public target::ExperimentalObserver {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
 
-    devtools_client_->GetBrowser()->GetExperimental()->AddObserver(this);
-    devtools_client_->GetBrowser()->GetExperimental()->CreateBrowserContext(
-        browser::CreateBrowserContextParams::Builder().Build(),
-        base::Bind(&BrowserDomainCreateTwoContexts::OnContextOneCreated,
+    devtools_client_->GetTarget()->GetExperimental()->AddObserver(this);
+    devtools_client_->GetTarget()->GetExperimental()->CreateBrowserContext(
+        target::CreateBrowserContextParams::Builder().Build(),
+        base::Bind(&TargetDomainCreateTwoContexts::OnContextOneCreated,
                    base::Unretained(this)));
 
-    devtools_client_->GetBrowser()->GetExperimental()->CreateBrowserContext(
-        browser::CreateBrowserContextParams::Builder().Build(),
-        base::Bind(&BrowserDomainCreateTwoContexts::OnContextTwoCreated,
+    devtools_client_->GetTarget()->GetExperimental()->CreateBrowserContext(
+        target::CreateBrowserContextParams::Builder().Build(),
+        base::Bind(&TargetDomainCreateTwoContexts::OnContextTwoCreated,
                    base::Unretained(this)));
   }
 
   void OnContextOneCreated(
-      std::unique_ptr<browser::CreateBrowserContextResult> result) {
+      std::unique_ptr<target::CreateBrowserContextResult> result) {
     context_id_one_ = result->GetBrowserContextId();
     MaybeCreatePages();
   }
 
   void OnContextTwoCreated(
-      std::unique_ptr<browser::CreateBrowserContextResult> result) {
+      std::unique_ptr<target::CreateBrowserContextResult> result) {
     context_id_two_ = result->GetBrowserContextId();
     MaybeCreatePages();
   }
 
   void MaybeCreatePages() {
     if (context_id_one_.empty() || context_id_two_.empty())
       return;
 
-    devtools_client_->GetBrowser()->GetExperimental()->CreateTarget(
-        browser::CreateTargetParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->CreateTarget(
+        target::CreateTargetParams::Builder()
             .SetUrl(embedded_test_server()->GetURL("/hello.html").spec())
             .SetBrowserContextId(context_id_one_)
             .Build(),
-        base::Bind(&BrowserDomainCreateTwoContexts::OnCreateTargetOneResult,
+        base::Bind(&TargetDomainCreateTwoContexts::OnCreateTargetOneResult,
                    base::Unretained(this)));
 
-    devtools_client_->GetBrowser()->GetExperimental()->CreateTarget(
-        browser::CreateTargetParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->CreateTarget(
+        target::CreateTargetParams::Builder()
             .SetUrl(embedded_test_server()->GetURL("/hello.html").spec())
             .SetBrowserContextId(context_id_two_)
             .Build(),
-        base::Bind(&BrowserDomainCreateTwoContexts::OnCreateTargetTwoResult,
+        base::Bind(&TargetDomainCreateTwoContexts::OnCreateTargetTwoResult,
                    base::Unretained(this)));
   }
 
   void OnCreateTargetOneResult(
-      std::unique_ptr<browser::CreateTargetResult> result) {
+      std::unique_ptr<target::CreateTargetResult> result) {
     page_id_one_ = result->GetTargetId();
     MaybeTestIsolation();
   }
 
   void OnCreateTargetTwoResult(
-      std::unique_ptr<browser::CreateTargetResult> result) {
+      std::unique_ptr<target::CreateTargetResult> result) {
     page_id_two_ = result->GetTargetId();
     MaybeTestIsolation();
   }
 
   void MaybeTestIsolation() {
     if (page_id_one_.empty() || page_id_two_.empty())
       return;
 
-    devtools_client_->GetBrowser()->GetExperimental()->Attach(
-        browser::AttachParams::Builder().SetTargetId(page_id_one_).Build(),
-        base::Bind(&BrowserDomainCreateTwoContexts::OnAttachedOne,
+    devtools_client_->GetTarget()->GetExperimental()->AttachToTarget(
+        target::AttachToTargetParams::Builder()
+            .SetTargetId(page_id_one_)
+            .Build(),
+        base::Bind(&TargetDomainCreateTwoContexts::OnAttachedToTargetOne,
                    base::Unretained(this)));
 
-    devtools_client_->GetBrowser()->GetExperimental()->Attach(
-        browser::AttachParams::Builder().SetTargetId(page_id_two_).Build(),
-        base::Bind(&BrowserDomainCreateTwoContexts::OnAttachedTwo,
+    devtools_client_->GetTarget()->GetExperimental()->AttachToTarget(
+        target::AttachToTargetParams::Builder()
+            .SetTargetId(page_id_two_)
+            .Build(),
+        base::Bind(&TargetDomainCreateTwoContexts::OnAttachedToTargetTwo,
                    base::Unretained(this)));
   }
 
-  void OnAttachedOne(std::unique_ptr<browser::AttachResult> result) {
-    devtools_client_->GetBrowser()->GetExperimental()->SendMessage(
-        browser::SendMessageParams::Builder()
+  void OnAttachedToTargetOne(
+      std::unique_ptr<target::AttachToTargetResult> result) {
+    devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
+        target::SendMessageToTargetParams::Builder()
             .SetTargetId(page_id_one_)
             .SetMessage("{\"id\":101, \"method\": \"Page.enable\"}")
             .Build());
   }
 
-  void OnAttachedTwo(std::unique_ptr<browser::AttachResult> result) {
-    devtools_client_->GetBrowser()->GetExperimental()->SendMessage(
-        browser::SendMessageParams::Builder()
+  void OnAttachedToTargetTwo(
+      std::unique_ptr<target::AttachToTargetResult> result) {
+    devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
+        target::SendMessageToTargetParams::Builder()
             .SetTargetId(page_id_two_)
             .SetMessage("{\"id\":102, \"method\": \"Page.enable\"}")
             .Build());
   }
 
   void MaybeSetCookieOnPageOne() {
     if (!page_one_loaded_ || !page_two_loaded_)
       return;
 
-    devtools_client_->GetBrowser()->GetExperimental()->SendMessage(
-        browser::SendMessageParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
+        target::SendMessageToTargetParams::Builder()
             .SetTargetId(page_id_one_)
             .SetMessage("{\"id\":201, \"method\": \"Runtime.evaluate\", "
                         "\"params\": {\"expression\": "
                         "\"document.cookie = 'foo=bar';\"}}")
             .Build());
   }
 
-  void OnDispatchMessage(
-      const browser::DispatchMessageParams& params) override {
+  void OnReceivedMessageFromTarget(
+      const target::ReceivedMessageFromTargetParams& params) override {
     std::unique_ptr<base::Value> message =
         base::JSONReader::Read(params.GetMessage(), base::JSON_PARSE_RFC);
     const base::DictionaryValue* message_dict;
     if (!message || !message->GetAsDictionary(&message_dict)) {
       return;
     }
     std::string method;
     if (message_dict->GetString("method", &method) &&
         method == "Page.loadEventFired") {
       if (params.GetTargetId() == page_id_one_) {
         page_one_loaded_ = true;
       } else if (params.GetTargetId() == page_id_two_) {
         page_two_loaded_ = true;
       }
       MaybeSetCookieOnPageOne();
       return;
     }
     const base::DictionaryValue* result_dict;
     if (message_dict->GetDictionary("result", &result_dict)) {
       // There's a nested result. We want the inner one.
       if (!result_dict->GetDictionary("result", &result_dict))
         return;
       std::string value;
       if (params.GetTargetId() == page_id_one_) {
-        // TODO(alexclarke): Make some better bindings for Browser.sendMessage.
-        devtools_client_->GetBrowser()->GetExperimental()->SendMessage(
-            browser::SendMessageParams::Builder()
+        // TODO(alexclarke): Make some better bindings
+        // for Target.SendMessageToTarget.
+        devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
+            target::SendMessageToTargetParams::Builder()
                 .SetTargetId(page_id_two_)
                 .SetMessage("{\"id\":202, \"method\": \"Runtime.evaluate\", "
                             "\"params\": {\"expression\": "
                             "\"document.cookie;\"}}")
                 .Build());
       } else if (params.GetTargetId() == page_id_two_ &&
                  result_dict->GetString("value", &value)) {
         EXPECT_EQ("", value) << "Page 2 should not share cookies from page one";
 
-        devtools_client_->GetBrowser()->GetExperimental()->CloseTarget(
-            browser::CloseTargetParams::Builder()
+        devtools_client_->GetTarget()->GetExperimental()->CloseTarget(
+            target::CloseTargetParams::Builder()
                 .SetTargetId(page_id_one_)
                 .Build(),
-            base::Bind(&BrowserDomainCreateTwoContexts::OnCloseTarget,
+            base::Bind(&TargetDomainCreateTwoContexts::OnCloseTarget,
                        base::Unretained(this)));
 
-        devtools_client_->GetBrowser()->GetExperimental()->CloseTarget(
-            browser::CloseTargetParams::Builder()
+        devtools_client_->GetTarget()->GetExperimental()->CloseTarget(
+            target::CloseTargetParams::Builder()
                 .SetTargetId(page_id_two_)
                 .Build(),
-            base::Bind(&BrowserDomainCreateTwoContexts::OnCloseTarget,
+            base::Bind(&TargetDomainCreateTwoContexts::OnCloseTarget,
                        base::Unretained(this)));
 
-        devtools_client_->GetBrowser()->GetExperimental()->RemoveObserver(this);
+        devtools_client_->GetTarget()->GetExperimental()->RemoveObserver(this);
       }
     }
   }
 
-  void OnCloseTarget(std::unique_ptr<browser::CloseTargetResult> result) {
+  void OnCloseTarget(std::unique_ptr<target::CloseTargetResult> result) {
     page_close_count_++;
 
     if (page_close_count_ < 2)
       return;
 
-    devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext(
-        browser::DisposeBrowserContextParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->DisposeBrowserContext(
+        target::DisposeBrowserContextParams::Builder()
             .SetBrowserContextId(context_id_one_)
             .Build(),
-        base::Bind(&BrowserDomainCreateTwoContexts::OnCloseContext,
+        base::Bind(&TargetDomainCreateTwoContexts::OnCloseContext,
                    base::Unretained(this)));
 
-    devtools_client_->GetBrowser()->GetExperimental()->DisposeBrowserContext(
-        browser::DisposeBrowserContextParams::Builder()
+    devtools_client_->GetTarget()->GetExperimental()->DisposeBrowserContext(
+        target::DisposeBrowserContextParams::Builder()
             .SetBrowserContextId(context_id_two_)
             .Build(),
-        base::Bind(&BrowserDomainCreateTwoContexts::OnCloseContext,
+        base::Bind(&TargetDomainCreateTwoContexts::OnCloseContext,
                    base::Unretained(this)));
   }
 
   void OnCloseContext(
-      std::unique_ptr<browser::DisposeBrowserContextResult> result) {
+      std::unique_ptr<target::DisposeBrowserContextResult> result) {
     EXPECT_TRUE(result->GetSuccess());
     if (++context_closed_count_ < 2)
       return;
 
     FinishAsynchronousTest();
   }
 
  private:
   std::string context_id_one_;
   std::string context_id_two_;
   std::string page_id_one_;
   std::string page_id_two_;
   bool page_one_loaded_ = false;
   bool page_two_loaded_ = false;
   int page_close_count_ = 0;
   int context_closed_count_ = 0;
 };
 
-HEADLESS_ASYNC_DEVTOOLED_TEST_F(BrowserDomainCreateTwoContexts);
+HEADLESS_ASYNC_DEVTOOLED_TEST_F(TargetDomainCreateTwoContexts);
 
 class HeadlessDevToolsNavigationControlTest
     : public HeadlessAsyncDevTooledBrowserTest,
       page::ExperimentalObserver {
  public:
   void RunDevTooledTest() override {
     EXPECT_TRUE(embedded_test_server()->Start());
     devtools_client_->GetPage()->GetExperimental()->AddObserver(this);
     devtools_client_->GetPage()->Enable();
     devtools_client_->GetPage()->GetExperimental()->SetControlNavigations(
@@ skipping 21 matching lines @@
     FinishAsynchronousTest();
   }
 
  private:
   bool navigation_requested_ = false;
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(HeadlessDevToolsNavigationControlTest);
 
 }  // namespace headless