[DevTools] Explicitly reset context group when clearing ScriptController.

content/renderer/render_view_browsertest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 #include <tuple>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 56 matching lines @@
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
 #include "third_party/WebKit/public/web/WebFrameContentDumper.h"
 #include "third_party/WebKit/public/web/WebHistoryCommitType.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPerformance.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
+#include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSettings.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebWindowFeatures.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/range/range.h"
 
 #if defined(USE_AURA) && defined(USE_X11)
 #include <X11/Xlib.h>
@@ skipping 289 matching lines @@
   }
 
  private:
   std::unique_ptr<MockKeyboard> mock_keyboard_;
 };
 
 class DevToolsAgentTest : public RenderViewImplTest {
  public:
   void Attach() {
     notifications_ = std::vector<std::string>();
+    expecting_pause_ = false;
     std::string host_id = "host_id";
     agent()->OnAttach(host_id, 17);
     agent()->send_protocol_message_callback_for_test_ = base::Bind(
        &DevToolsAgentTest::OnDevToolsMessage, base::Unretained(this));
   }
 
   void Detach() {
     agent()->send_protocol_message_callback_for_test_.Reset();
     agent()->OnDetach();
   }
 
   bool IsPaused() {
     return agent()->paused_;
   }
 
   void DispatchDevToolsMessage(const std::string& method,
                                const std::string& message) {
     agent()->OnDispatchOnInspectorBackend(17, 1, method, message);
   }
 
   void CloseWhilePaused() {
     EXPECT_TRUE(IsPaused());
     view()->NotifyOnClose();
   }
 
   void OnDevToolsMessage(
       int, int, const std::string& message, const std::string&) {
-    last_received_message_ = message;
-    std::unique_ptr<base::DictionaryValue> root(
-        static_cast<base::DictionaryValue*>(
-            base::JSONReader::Read(message).release()));
+    last_message_ = base::WrapUnique(static_cast<base::DictionaryValue*>(
+        base::JSONReader::Read(message).release()));
     int id;
-    if (!root->GetInteger("id", &id)) {
+    if (!last_message_->GetInteger("id", &id)) {
       std::string notification;
-      EXPECT_TRUE(root->GetString("method", &notification));
+      EXPECT_TRUE(last_message_->GetString("method", &notification));
       notifications_.push_back(notification);
+
+      if (notification == "Debugger.paused" && expecting_pause_) {
+        base::ListValue* call_frames;
+        EXPECT_TRUE(last_message_->GetList("params.callFrames", &call_frames));
+        if (call_frames) {
+          EXPECT_EQ(call_frames_count_,
+                    static_cast<int>(call_frames->GetSize()));
+        }
+        expecting_pause_ = false;
+        base::ThreadTaskRunnerHandle::Get()->PostTask(
+            FROM_HERE,
+            base::Bind(&DevToolsAgentTest::DispatchDevToolsMessage,
+                       base::Unretained(this),
+                       "Debugger.resume",
+                       "{\"id\":100,\"method\":\"Debugger.resume\"}"));
+      }
     }
   }
 
   int CountNotifications(const std::string& notification) {
     int result = 0;
     for (const std::string& s : notifications_) {
       if (s == notification)
         ++result;
     }
     return result;
   }
 
-  std::string LastReceivedMessage() const { return last_received_message_; }
+  base::DictionaryValue* LastReceivedMessage() {
+    return last_message_.get();
+  }
+
+  void ExpectPauseAndResume(int call_frames_count) {
+    expecting_pause_ = true;
+    call_frames_count_ = call_frames_count;
+  }
 
  private:
   DevToolsAgent* agent() {
     return frame()->devtools_agent();
   }
 
   std::vector<std::string> notifications_;
-  std::string last_received_message_;
+  std::unique_ptr<base::DictionaryValue> last_message_;
+  int call_frames_count_;
+  bool expecting_pause_;
 };
 
 class RenderViewImplBlinkSettingsTest : public RenderViewImplTest {
  public:
   virtual void DoSetUp() {
     RenderViewImplTest::SetUp();
   }
 
   blink::WebSettings* settings() {
     return view()->webview()->settings();
@@ skipping 2025 matching lines @@
   DispatchDevToolsMessage("Console.enable",
                           "{\"id\":1,\"method\":\"Console.enable\"}");
   DispatchDevToolsMessage("Runtime.evaluate",
                           "{\"id\":2,"
                           "\"method\":\"Runtime.evaluate\","
                           "\"params\":{"
                           "\"expression\":\"window\""
                           "}"
                           "}");
 
-  std::unique_ptr<base::DictionaryValue> root(
-      static_cast<base::DictionaryValue*>(
-          base::JSONReader::Read(LastReceivedMessage()).release()));
+  base::DictionaryValue* root = LastReceivedMessage();
   const base::Value* object_id;
   ASSERT_TRUE(root->Get("result.result.objectId", &object_id));
   std::string object_id_str;
   EXPECT_TRUE(base::JSONWriter::Write(*object_id, &object_id_str));
 
   DispatchDevToolsMessage("Runtime.callFunctionOn",
                           "{\"id\":3,"
                           "\"method\":\"Runtime.callFunctionOn\","
                           "\"params\":{"
                           "\"objectId\":" +
                               object_id_str +
                               ","
                               "\"functionDeclaration\":\"function foo(){ "
                               "Promise.resolve().then(() => "
                               "console.log(239))}\""
                               "}"
                               "}");
   EXPECT_EQ(1, CountNotifications("Console.messageAdded"));
 }
 
+TEST_F(DevToolsAgentTest, CallFramesInIsolatedWorld) {
+  LoadHTML("<body>page</body>");
+  blink::WebScriptSource source1(
+      WebString::fromUTF8("function func1() { debugger; }"));
+  frame()->GetWebFrame()->executeScriptInIsolatedWorld(17, &source1, 1, 1);
+
+  Attach();
+  DispatchDevToolsMessage("Debugger.enable",
+                          "{\"id\":1,\"method\":\"Debugger.enable\"}");
+
+  ExpectPauseAndResume(3);
+  blink::WebScriptSource source2(
+      WebString::fromUTF8("function func2() { func1(); }; func2();"));
+  frame()->GetWebFrame()->executeScriptInIsolatedWorld(17, &source2, 1, 1);
+
+  EXPECT_FALSE(IsPaused());
+  Detach();
+}
+
 }  // namespace content