[DevTools] Support multiple sessions in Target domain

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 "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 660 matching lines @@
     MaybeTestIsolation();
   }
 
   void MaybeTestIsolation() {
     if (page_id_one_.empty() || page_id_two_.empty())
       return;
 
     devtools_client_->GetTarget()->GetExperimental()->AttachToTarget(
         target::AttachToTargetParams::Builder()
             .SetTargetId(page_id_one_)
-            .Build(),
-        base::Bind(&TargetDomainCreateTwoContexts::OnAttachedToTargetOne,
-                   base::Unretained(this)));
+            .Build());
 
     devtools_client_->GetTarget()->GetExperimental()->AttachToTarget(
         target::AttachToTargetParams::Builder()
             .SetTargetId(page_id_two_)
-            .Build(),
-        base::Bind(&TargetDomainCreateTwoContexts::OnAttachedToTargetTwo,
-                   base::Unretained(this)));
+            .Build());
   }
 
-  void OnAttachedToTargetOne(
-      std::unique_ptr<target::AttachToTargetResult> result) {
-    StopNavigationOnTarget(101, page_id_one_);
+  void OnAttachedToTarget(
+      const target::AttachedToTargetParams& params) override {
+    if (session_id_one_.empty()) {
+      session_id_one_ = params.GetSessionId();
+      StopNavigationOnTarget(101, session_id_one_);
+    } else {
+      EXPECT_TRUE(session_id_two_.empty());
+      session_id_two_ = params.GetSessionId();
+      StopNavigationOnTarget(102, session_id_two_);
+    }
   }
 
-  void OnAttachedToTargetTwo(
-      std::unique_ptr<target::AttachToTargetResult> result) {
-    StopNavigationOnTarget(102, page_id_two_);
-  }
-
-  void StopNavigationOnTarget(int message_id, std::string target_id) {
+  void StopNavigationOnTarget(int message_id, std::string session_id) {
     // Avoid triggering Page.loadEventFired for about://blank if loading hasn't
     // finished yet.
     devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
         target::SendMessageToTargetParams::Builder()
-            .SetTargetId(target_id)
+            .SetSessionId(session_id)
             .SetMessage("{\"id\":" + std::to_string(message_id) +
                         ", \"method\": \"Page.stopLoading\"}")
             .Build());
   }
 
-  void EnablePageOnTarget(int message_id, std::string target_id) {
+  void EnablePageOnTarget(int message_id, std::string session_id) {
     devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
         target::SendMessageToTargetParams::Builder()
-            .SetTargetId(target_id)
+            .SetSessionId(session_id)
             .SetMessage("{\"id\":" + std::to_string(message_id) +
                         ", \"method\": \"Page.enable\"}")
             .Build());
   }
 
-  void NavigateTarget(int message_id, std::string target_id) {
+  void NavigateTarget(int message_id, std::string session_id) {
     devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
         target::SendMessageToTargetParams::Builder()
-            .SetTargetId(target_id)
+            .SetSessionId(session_id)
             .SetMessage(
                 "{\"id\":" + std::to_string(message_id) +
                 ", \"method\": \"Page.navigate\", \"params\": {\"url\": \"" +
                 embedded_test_server()->GetURL("/hello.html").spec() + "\"}}")
             .Build());
   }
 
   void MaybeSetCookieOnPageOne() {
     if (!page_one_loaded_ || !page_two_loaded_)
       return;
 
     devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
         target::SendMessageToTargetParams::Builder()
-            .SetTargetId(page_id_one_)
+            .SetSessionId(session_id_one_)
             .SetMessage("{\"id\":401, \"method\": \"Runtime.evaluate\", "
                         "\"params\": {\"expression\": "
                         "\"document.cookie = 'foo=bar';\"}}")
             .Build());
   }
 
   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_) {
+      if (params.GetSessionId() == session_id_one_) {
         page_one_loaded_ = true;
-      } else if (params.GetTargetId() == page_id_two_) {
+      } else if (params.GetSessionId() == session_id_two_) {
         page_two_loaded_ = true;
       }
       MaybeSetCookieOnPageOne();
       return;
     }
 
     int message_id = 0;
     if (!message_dict->GetInteger("id", &message_id))
       return;
     const base::DictionaryValue* result_dict;
     if (message_dict->GetDictionary("result", &result_dict)) {
       if (message_id == 101) {
         // 101: Page.stopNavigation on target one.
-        EXPECT_EQ(page_id_one_, params.GetTargetId());
-        EnablePageOnTarget(201, page_id_one_);
+        EXPECT_EQ(session_id_one_, params.GetSessionId());
+        EnablePageOnTarget(201, session_id_one_);
       } else if (message_id == 102) {
         // 102: Page.stopNavigation on target two.
-        EXPECT_EQ(page_id_two_, params.GetTargetId());
-        EnablePageOnTarget(202, page_id_two_);
+        EXPECT_EQ(session_id_two_, params.GetSessionId());
+        EnablePageOnTarget(202, session_id_two_);
       } else if (message_id == 201) {
         // 201: Page.enable on target one.
-        EXPECT_EQ(page_id_one_, params.GetTargetId());
-        NavigateTarget(301, page_id_one_);
+        EXPECT_EQ(session_id_one_, params.GetSessionId());
+        NavigateTarget(301, session_id_one_);
       } else if (message_id == 202) {
         // 202: Page.enable on target two.
-        EXPECT_EQ(page_id_two_, params.GetTargetId());
-        NavigateTarget(302, page_id_two_);
+        EXPECT_EQ(session_id_two_, params.GetSessionId());
+        NavigateTarget(302, session_id_two_);
       } else if (message_id == 401) {
         // 401: Runtime.evaluate on target one.
-        EXPECT_EQ(page_id_one_, params.GetTargetId());
+        EXPECT_EQ(session_id_one_, params.GetSessionId());
 
         // TODO(alexclarke): Make some better bindings
         // for Target.SendMessageToTarget.
         devtools_client_->GetTarget()->GetExperimental()->SendMessageToTarget(
             target::SendMessageToTargetParams::Builder()
-                .SetTargetId(page_id_two_)
+                .SetSessionId(session_id_two_)
                 .SetMessage("{\"id\":402, \"method\": \"Runtime.evaluate\", "
                             "\"params\": {\"expression\": "
                             "\"document.cookie;\"}}")
                 .Build());
       } else if (message_id == 402) {
         // 402: Runtime.evaluate on target two.
-        EXPECT_EQ(page_id_two_, params.GetTargetId());
+        EXPECT_EQ(session_id_two_, params.GetSessionId());
 
         // There's a nested result. We want the inner one.
         EXPECT_TRUE(result_dict->GetDictionary("result", &result_dict));
 
         std::string value;
         EXPECT_TRUE(result_dict->GetString("value", &value));
         EXPECT_EQ("", value) << "Page 2 should not share cookies from page one";
 
         devtools_client_->GetTarget()->GetExperimental()->CloseTarget(
             target::CloseTargetParams::Builder()
@@ skipping 42 matching lines @@
       return;
 
     FinishAsynchronousTest();
   }
 
  private:
   std::string context_id_one_;
   std::string context_id_two_;
   std::string page_id_one_;
   std::string page_id_two_;
+  std::string session_id_one_;
+  std::string session_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(TargetDomainCreateTwoContexts);
 
 class HeadlessDevToolsNavigationControlTest
     : public HeadlessAsyncDevTooledBrowserTest,
@@ skipping 1374 matching lines @@
           << " Style # " << i;
     }
 
     FinishAsynchronousTest();
   }
 };
 
 HEADLESS_ASYNC_DEVTOOLED_TEST_F(DomTreeExtractionBrowserTest);
 
 }  // namespace headless