DevTools: allow addScriptToEvaluateOnNewDocument accept optional worldName parameter.

Change-Id: I573cc9766e05d24eb9288c7bd5cd25a53c1d0b72
Reviewed-on: https://chromium-review.googlesource.com/1247186
Commit-Queue: Pavel Feldman <pfeldman@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#594544}

third_party/WebKit/LayoutTests/inspector-protocol/page/add-script-to-evaluate-in-world-expected.txt

+Tests that Page.addScriptToEvaluateOnNewDocument is executed in the given world
+Adding scripts
+world#0
+message from 0
+world#1
+message from 1
+world#2
+message from 2
+world#3
+message from 3
+world#4
+message from 4
+Removing scripts
+

third_party/WebKit/LayoutTests/inspector-protocol/page/add-script-to-evaluate-in-world.js

+(async function(testRunner) {
+  const {page, session, dp} = await testRunner.startBlank(
+      'Tests that Page.addScriptToEvaluateOnNewDocument is executed in the given world');
+  dp.Runtime.enable();
+  dp.Page.enable();
+
+  const scriptIds = [];
+  dp.Runtime.onConsoleAPICalled(msg => testRunner.log(msg.params.args[0].value));
+  dp.Runtime.onExecutionContextCreated(msg => {
+    if (msg.params.context.name.includes('world'))
+      testRunner.log(msg.params.context.name);
+  });
+
+  testRunner.log('Adding scripts');
+  for (let i = 0; i < 5; ++i) {
+    const result = await dp.Page.addScriptToEvaluateOnNewDocument({source: `
+      console.log('message from ${i}');`, worldName: `world#${i}`});
+    scriptIds.push(result.result.identifier);
+  }
+
+  await session.navigate('../resources/blank.html');
+
+  testRunner.log('Removing scripts');
+  for (let identifier of scriptIds) {
+    const response = await dp.Page.removeScriptToEvaluateOnNewDocument({identifier});
+    if (!response.result)
+      testRunner.log('Failed script removal');
+  }
+
+  await session.navigate('../resources/blank.html');
+
+  testRunner.completeTest();
+})

third_party/WebKit/LayoutTests/inspector-protocol/page/add-script-to-evaluate-on-load-expected.txt

 Tests that Page.addScriptToEvaluateOnLoad is executed in the order of addition
+Adding scripts
 message from 0
 message from 1
 message from 2
 message from 3
 message from 4
-message from 5
-message from 6
-message from 7
-message from 8
-message from 9
-message from 10
-message from 11
-message from 12
-message from 13
-message from 14
+Removing scripts
 

third_party/WebKit/LayoutTests/inspector-protocol/page/add-script-to-evaluate-on-load.js

@@ -4,13 +4,27 @@
   dp.Runtime.enable();
   dp.Page.enable();
 
+  const scriptIds = [];
   dp.Runtime.onConsoleAPICalled(msg => testRunner.log(msg.params.args[0].value));
 
-  for (let i = 0; i < 15; ++i) {
-    await dp.Page.addScriptToEvaluateOnNewDocument({source: `
+  testRunner.log('Adding scripts');
+  for (let i = 0; i < 5; ++i) {
+    const result = await dp.Page.addScriptToEvaluateOnNewDocument({source: `
       console.log('message from ${i}');
     `});
+    scriptIds.push(result.result.identifier);
   }
+
+  await session.navigate('../resources/blank.html');
+
+  testRunner.log('Removing scripts');
+  for (let identifier of scriptIds) {
+    const response = await dp.Page.removeScriptToEvaluateOnNewDocument({identifier});
+    if (!response.result)
+      testRunner.log('Failed script removal');
+  }
+
   await session.navigate('../resources/blank.html');
+
   testRunner.completeTest();
 })

third_party/blink/renderer/core/inspector/browser_protocol.pdl

@@ -4870,6 +4870,10 @@ domain Page
   command addScriptToEvaluateOnNewDocument
     parameters
       string source
+      # If specified, creates an isolated world with the given name and evaluates given script in it.
+      # This world name will be used as the ExecutionContextDescription::name when the corresponding
+      # event is emitted.
+      experimental optional string worldName
     returns
       # Identifier of the added script.
       ScriptIdentifier identifier

third_party/blink/renderer/core/inspector/inspector_page_agent.cc

@@ -463,6 +463,8 @@ InspectorPageAgent::InspectorPageAgent(
       bypass_csp_enabled_(&agent_state_, /*default_value=*/false),
       scripts_to_evaluate_on_load_(&agent_state_,
                                    /*default_value=*/WTF::String()),
+      worlds_to_evaluate_on_load_(&agent_state_,
+                                  /*default_value=*/WTF::String()),
       standard_font_family_(&agent_state_, /*default_value=*/WTF::String()),
       fixed_font_family_(&agent_state_, /*default_value=*/WTF::String()),
       serif_font_family_(&agent_state_, /*default_value=*/WTF::String()),
@@ -548,39 +550,44 @@ Response InspectorPageAgent::disable() {
   return Response::OK();
 }
 
-Response InspectorPageAgent::addScriptToEvaluateOnLoad(const String& source,
-                                                       String* identifier) {
+Response InspectorPageAgent::addScriptToEvaluateOnNewDocument(
+    const String& source,
+    Maybe<String> world_name,
+    String* identifier) {
   std::vector<WTF::String> keys = scripts_to_evaluate_on_load_.Keys();
   auto result = std::max_element(
       keys.begin(), keys.end(), [](const WTF::String& a, const WTF::String& b) {
         return Decimal::FromString(a) < Decimal::FromString(b);
       });
   if (result == keys.end()) {
-    scripts_to_evaluate_on_load_.Set(String::Number(1), source);
+    *identifier = String::Number(1);
   } else {
-    scripts_to_evaluate_on_load_.Set(
-        String::Number(Decimal::FromString(*result).ToDouble() + 1), source);
+    *identifier = String::Number(Decimal::FromString(*result).ToDouble() + 1);
   }
+
+  scripts_to_evaluate_on_load_.Set(*identifier, source);
+  worlds_to_evaluate_on_load_.Set(*identifier, world_name.fromMaybe(""));
   return Response::OK();
 }
 
-Response InspectorPageAgent::removeScriptToEvaluateOnLoad(
+Response InspectorPageAgent::removeScriptToEvaluateOnNewDocument(
     const String& identifier) {
   if (scripts_to_evaluate_on_load_.Get(identifier).IsNull())
     return Response::Error("Script not found");
   scripts_to_evaluate_on_load_.Clear(identifier);
+  worlds_to_evaluate_on_load_.Clear(identifier);
   return Response::OK();
 }
 
-Response InspectorPageAgent::addScriptToEvaluateOnNewDocument(
-    const String& source,
-    String* identifier) {
-  return addScriptToEvaluateOnLoad(source, identifier);
+Response InspectorPageAgent::addScriptToEvaluateOnLoad(const String& source,
+                                                       String* identifier) {
+  return addScriptToEvaluateOnNewDocument(source, Maybe<String>(""),
+                                          identifier);
 }
 
-Response InspectorPageAgent::removeScriptToEvaluateOnNewDocument(
+Response InspectorPageAgent::removeScriptToEvaluateOnLoad(
     const String& identifier) {
-  return removeScriptToEvaluateOnLoad(identifier);
+  return removeScriptToEvaluateOnNewDocument(identifier);
 }
 
 Response InspectorPageAgent::setLifecycleEventsEnabled(bool enabled) {
@@ -843,10 +850,40 @@ void InspectorPageAgent::DidClearDocumentOfWindowObject(LocalFrame* frame) {
               return Decimal::FromString(a) < Decimal::FromString(b);
             });
 
+  HashMap<String, int> world_id_by_name;
   for (const WTF::String& key : keys) {
-    const WTF::String& script = scripts_to_evaluate_on_load_.Get(key);
-    frame->GetScriptController().ExecuteScriptInMainWorld(script);
+    const String source = scripts_to_evaluate_on_load_.Get(key);
+    const String world_name = worlds_to_evaluate_on_load_.Get(key);
+    if (world_name.IsEmpty()) {
+      frame->GetScriptController().ExecuteScriptInMainWorld(source);
+      continue;
+    }
+
+    auto it = world_id_by_name.find(world_name);
+    int world_id = 0;
+    if (it != world_id_by_name.end()) {
+      world_id = it->value;
+    } else {
+      scoped_refptr<DOMWrapperWorld> world =
+          frame->GetScriptController().CreateNewInspectorIsolatedWorld(
+              world_name);
+      if (!world)
+        continue;
+      world_id = world->GetWorldId();
+      world_id_by_name.Set(world_name, world_id);
+
+      scoped_refptr<SecurityOrigin> security_origin =
+          frame->GetSecurityContext()->GetSecurityOrigin()->IsolatedCopy();
+      security_origin->GrantUniversalAccess();
+      DOMWrapperWorld::SetIsolatedWorldSecurityOrigin(world_id,
+                                                      security_origin);
+    }
+
+    v8::HandleScope handle_scope(V8PerIsolateData::MainThreadIsolate());
+    frame->GetScriptController().ExecuteScriptInIsolatedWorld(
+        world_id, source, KURL(), kNotSharableCrossOrigin);
   }
+
   if (!script_to_evaluate_on_load_once_.IsEmpty()) {
     frame->GetScriptController().ExecuteScriptInMainWorld(
         script_to_evaluate_on_load_once_);

third_party/blink/renderer/core/inspector/inspector_page_agent.h

@@ -115,6 +115,7 @@ class CORE_EXPORT InspectorPageAgent final
       const String& identifier) override;
   protocol::Response addScriptToEvaluateOnNewDocument(
       const String& source,
+      Maybe<String> world_name,
       String* identifier) override;
   protocol::Response removeScriptToEvaluateOnNewDocument(
       const String& identifier) override;
@@ -249,6 +250,7 @@ class CORE_EXPORT InspectorPageAgent final
   InspectorAgentState::Boolean lifecycle_events_enabled_;
   InspectorAgentState::Boolean bypass_csp_enabled_;
   InspectorAgentState::StringMap scripts_to_evaluate_on_load_;
+  InspectorAgentState::StringMap worlds_to_evaluate_on_load_;
   InspectorAgentState::String standard_font_family_;
   InspectorAgentState::String fixed_font_family_;
   InspectorAgentState::String serif_font_family_;