DevTools: introduce Target.createBrowserContext({disposeOnDetach})

Passing this parameter will desotry all the contexts created by the session
upon session disconnect.

Change-Id: I6608ef672b41b922308bf71921a074faa037ae7e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2042279
Commit-Queue: Pavel Feldman <pfeldman@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Cr-Commit-Position: refs/heads/master@{#739214}

content/browser/devtools/protocol/target_handler.cc

@@ -503,6 +503,22 @@ Response TargetHandler::Disable() {
   SetDiscoverTargets(false);
   auto_attached_sessions_.clear();
   attached_sessions_.clear();
+
+  DevToolsManagerDelegate* delegate =
+      DevToolsManager::GetInstance()->delegate();
+  if (!delegate)
+    return Response::OK();
+
+  if (dispose_on_detach_context_ids_.size()) {
+    for (auto* context : delegate->GetBrowserContexts()) {
+      if (!dispose_on_detach_context_ids_.contains(context->UniqueId()))
+        continue;
+      delegate->DisposeBrowserContext(
+          context,
+          base::BindOnce([](bool success, const std::string& error) {}));
+    }
+    dispose_on_detach_context_ids_.clear();
+  }
   return Response::OK();
 }
 
@@ -825,6 +841,7 @@ void TargetHandler::DevToolsAgentHostCrashed(DevToolsAgentHost* host,
 // ----------------- More protocol methods -------------------
 
 protocol::Response TargetHandler::CreateBrowserContext(
+    Maybe<bool> dispose_on_detach,
     std::string* out_context_id) {
   if (access_mode_ != AccessMode::kBrowser)
     return Response::Error(kNotAllowedError);
@@ -836,6 +853,8 @@ protocol::Response TargetHandler::CreateBrowserContext(
   if (!context)
     return Response::Error("Failed to create browser context.");
   *out_context_id = context->UniqueId();
+  if (dispose_on_detach.fromMaybe(false))
+    dispose_on_detach_context_ids_.insert(*out_context_id);
   return Response::OK();
 }
 
@@ -881,6 +900,7 @@ void TargetHandler::DisposeBrowserContext(
         Response::Error("Failed to find context with id " + context_id));
     return;
   }
+  dispose_on_detach_context_ids_.erase(context_id);
   delegate->DisposeBrowserContext(
       *context_it,
       base::BindOnce(

content/browser/devtools/protocol/target_handler.h

@@ -84,7 +84,8 @@ class TargetHandler : public DevToolsDomainHandler,
                        bool* out_success) override;
   Response ExposeDevToolsProtocol(const std::string& target_id,
                                   Maybe<std::string> binding_name) override;
-  Response CreateBrowserContext(std::string* out_context_id) override;
+  Response CreateBrowserContext(Maybe<bool> dispose_on_detach,
+                                std::string* out_context_id) override;
   void DisposeBrowserContext(
       const std::string& context_id,
       std::unique_ptr<DisposeBrowserContextCallback> callback) override;
@@ -136,6 +137,7 @@ class TargetHandler : public DevToolsDomainHandler,
   std::map<std::string, std::unique_ptr<Session>> attached_sessions_;
   std::map<DevToolsAgentHost*, Session*> auto_attached_sessions_;
   std::set<DevToolsAgentHost*> reported_hosts_;
+  base::flat_set<std::string> dispose_on_detach_context_ids_;
   AccessMode access_mode_;
   std::string owner_target_id_;
   DevToolsSession* root_session_;

headless/lib/browser/headless_browser_impl.cc

@@ -61,7 +61,9 @@ void HeadlessBrowserImpl::Shutdown() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   weak_ptr_factory_.InvalidateWeakPtrs();
-  browser_contexts_.clear();
+  // Make sure GetAllBrowserContexts is sane if called after this point.
+  auto tmp = std::move(browser_contexts_);
+  tmp.clear();
   if (system_request_context_manager_) {
     base::DeleteSoon(FROM_HERE, {content::BrowserThread::IO},
                      system_request_context_manager_.release());

headless/test/data/protocol/sessions/headless-createContext-disposeOnDetach-expected.txt

+Tests headless context destruction on session close.
+
+Creating context {disposeOnDetach: true} in session1
+Creating context {disposeOnDetach: true} in session1
+Creating context {disposeOnDetach: true} in session1
+Number of contexts created: 3
+Creating context {disposeOnDetach: false} in session2
+Creating context {disposeOnDetach: false} in session2
+Number of contexts created: 5
+Detaching from session1
+Number of contexts created: 2
+Detaching from session2
+Number of contexts created: 2
\ No newline at end of file

headless/test/data/protocol/sessions/headless-createContext-disposeOnDetach.js

+// Copyright 2020 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.
+
+(async function(testRunner) {
+  testRunner.log('Tests headless context destruction on session close.\n');
+
+  async function createSession() {
+    const {result: {sessionId}} =
+        await testRunner.browserP().Target.attachToBrowserTarget();
+    return new TestRunner.Session(testRunner, sessionId);
+  }
+
+  async function dumpContextNumber() {
+    const session = await createSession();
+    const {result} = await session.protocol.Target.getBrowserContexts();
+    testRunner.log(
+        'Number of contexts created: ' + result.browserContextIds.length);
+  }
+
+  const session1 = await createSession();
+  for (let i = 0; i < 3; ++i) {
+    testRunner.log('Creating context {disposeOnDetach: true} in session1');
+    await session1.protocol.Target.createBrowserContext(
+        {disposeOnDetach: true});
+  }
+  await dumpContextNumber();
+
+  const session2 = await createSession();
+  for (let i = 0; i < 2; ++i) {
+    testRunner.log('Creating context {disposeOnDetach: false} in session2');
+    await session2.protocol.Target.createBrowserContext(
+        {disposeOnDetach: false});
+  }
+  await dumpContextNumber();
+
+  testRunner.log('Detaching from session1');
+  await session1.disconnect();
+  await dumpContextNumber();
+
+  testRunner.log('Detaching from session2');
+  await session2.disconnect();
+  await dumpContextNumber();
+
+  testRunner.completeTest();
+})

headless/test/headless_protocol_browsertest.cc

@@ -274,6 +274,9 @@ HEADLESS_PROTOCOL_TEST(MAYBE_VirtualTimeTimerSuspend,
 HEADLESS_PROTOCOL_TEST(HeadlessSessionBasicsTest,
                        "sessions/headless-session-basics.js")
 
+HEADLESS_PROTOCOL_TEST(HeadlessSessionCreateContextDisposeOnDetach,
+                       "sessions/headless-createContext-disposeOnDetach.js")
+
 class HeadlessProtocolCompositorBrowserTest
     : public HeadlessProtocolBrowserTest {
  public:

third_party/blink/public/devtools_protocol/browser_protocol.pdl

@@ -6736,6 +6736,9 @@ domain Target
   # Creates a new empty BrowserContext. Similar to an incognito profile but you can have more than
   # one.
   experimental command createBrowserContext
+    parameters
+      # If specified, disposes this context when debugging session disconnects.
+      optional boolean disposeOnDetach
     returns
       # The id of the context created.
       Browser.BrowserContextID browserContextId