[DevTools] Pause input events in WebFrameWidgetImpl while debugging.

Source/web/WebDevToolsAgentImpl.cpp

 /*
  * Copyright (C) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 71 matching lines @@
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebString.h"
 #include "public/web/WebDevToolsAgentClient.h"
 #include "public/web/WebDeviceEmulationParams.h"
 #include "public/web/WebSettings.h"
 #include "public/web/WebViewClient.h"
 #include "web/DevToolsEmulator.h"
+#include "web/WebFrameWidgetImpl.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebSettingsImpl.h"
 #include "web/WebViewImpl.h"
 #include "wtf/MathExtras.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/ProcessID.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class ClientMessageLoopAdapter : public PageScriptDebugServer::ClientMessageLoop {
 public:
     ~ClientMessageLoopAdapter() override
     {
         s_instance = nullptr;
     }
 
     static void ensurePageScriptDebugServerCreated(WebDevToolsAgentClient* client)
     {
         if (s_instance)
             return;
         OwnPtr<ClientMessageLoopAdapter> instance = adoptPtr(new ClientMessageLoopAdapter(adoptPtr(client->createClientMessageLoop())));
         s_instance = instance.get();
         v8::Isolate* isolate = V8PerIsolateData::mainThreadIsolate();
         V8PerIsolateData* data = V8PerIsolateData::from(isolate);
         data->setScriptDebugServer(adoptPtrWillBeNoop(new PageScriptDebugServer(instance.release(), isolate)));
     }
 
-    static void inspectedViewClosed(WebViewImpl* view)
+    static void webViewImplClosed(WebViewImpl* view)
     {
         if (s_instance)
             s_instance->m_frozenViews.remove(view);
     }
 
-    static void didNavigate()
+    static void webFrameWidgetImplClosed(WebFrameWidgetImpl* widget)
+    {
+        if (s_instance)
+            s_instance->m_frozenWidgets.remove(widget);
+    }
+
+    static void continueProgram()
     {
         // Release render thread if necessary.
         if (s_instance && s_instance->m_running)
             PageScriptDebugServer::instance()->continueProgram();
     }
 
 private:
     ClientMessageLoopAdapter(PassOwnPtr<WebDevToolsAgentClient::WebKitClientMessageLoop> messageLoop)
         : m_running(false)
         , m_messageLoop(messageLoop) { }
 
     void run(LocalFrame* frame) override
     {
         if (m_running)
             return;
         m_running = true;
 
         // 0. Flush pending frontend messages.
         WebViewImpl* viewImpl = WebViewImpl::fromPage(frame->page());
         WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(viewImpl->devToolsAgent());
         agent->flushPendingProtocolNotifications();
 
         Vector<WebViewImpl*> views;
+        Vector<WebFrameWidgetImpl*> widgets;
 
         // 1. Disable input events.
-        const HashSet<Page*>& pages = Page::ordinaryPages();
-        HashSet<Page*>::const_iterator end = pages.end();
-        for (HashSet<Page*>::const_iterator it =  pages.begin(); it != end; ++it) {
-            WebViewImpl* view = WebViewImpl::fromPage(*it);
-            if (!view)
-                continue;
+        const HashSet<WebViewImpl*>& viewImpls = WebViewImpl::allInstances();
+        HashSet<WebViewImpl*>::const_iterator viewImplsEnd = viewImpls.end();
+        for (HashSet<WebViewImpl*>::const_iterator it =  viewImpls.begin(); it != viewImplsEnd; ++it) {
+            WebViewImpl* view = *it;
             m_frozenViews.add(view);
             views.append(view);
             view->setIgnoreInputEvents(true);
         }
-        // Notify embedder about pausing.
+
+        const HashSet<WebFrameWidgetImpl*>& widgetImpls = WebFrameWidgetImpl::allInstances();
+        HashSet<WebFrameWidgetImpl*>::const_iterator widgetImplsEnd = widgetImpls.end();
+        for (HashSet<WebFrameWidgetImpl*>::const_iterator it =  widgetImpls.begin(); it != widgetImplsEnd; ++it) {
+            WebFrameWidgetImpl* widget = *it;
+            m_frozenWidgets.add(widget);
+            widgets.append(widget);
+            widget->setIgnoreInputEvents(true);
+        }
+
+        // 2. Notify embedder about pausing.
         agent->client()->willEnterDebugLoop();
 
-        // 2. Disable active objects
+        // 3. Disable active objects
         WebView::willEnterModalLoop();
 
-        // 3. Process messages until quitNow is called.
+        // 4. Process messages until quitNow is called.
         m_messageLoop->run();
 
-        // 4. Resume active objects
+        // 5. Resume active objects
         WebView::didExitModalLoop();
 
-        // 5. Resume input events.
+        // 6. Resume input events.
         for (Vector<WebViewImpl*>::iterator it = views.begin(); it != views.end(); ++it) {
             if (m_frozenViews.contains(*it)) {
                 // The view was not closed during the dispatch.
                 (*it)->setIgnoreInputEvents(false);
             }
         }
+        for (Vector<WebFrameWidgetImpl*>::iterator it = widgets.begin(); it != widgets.end(); ++it) {
+            if (m_frozenWidgets.contains(*it)) {
+                // The widget was not closed during the dispatch.
+                (*it)->setIgnoreInputEvents(false);
+            }
+        }
+
+        // 7. Notify embedder about resuming.
         agent->client()->didExitDebugLoop();
 
-        // 6. All views have been resumed, clear the set.
+        // 8. All views have been resumed, clear the set.
         m_frozenViews.clear();
+        m_frozenWidgets.clear();
 
         m_running = false;
     }
 
     void quitNow() override
     {
         m_messageLoop->quitNow();
     }
 
     bool m_running;
     OwnPtr<WebDevToolsAgentClient::WebKitClientMessageLoop> m_messageLoop;
     typedef HashSet<WebViewImpl*> FrozenViewsSet;
     FrozenViewsSet m_frozenViews;
+    typedef HashSet<WebFrameWidgetImpl*> FrozenWidgetsSet;
+    FrozenWidgetsSet m_frozenWidgets;
     static ClientMessageLoopAdapter* s_instance;
 };
 
 ClientMessageLoopAdapter* ClientMessageLoopAdapter::s_instance = nullptr;
 
 class DebuggerTask : public PageScriptDebugServer::Task {
 public:
     DebuggerTask(PassOwnPtr<WebDevToolsAgent::MessageDescriptor> descriptor)
         : m_descriptor(descriptor)
     {
@@ skipping 89 matching lines @@
 
 WebDevToolsAgentImpl::~WebDevToolsAgentImpl()
 {
     ASSERT(m_hasBeenDisposed);
 }
 
 void WebDevToolsAgentImpl::dispose()
 {
     // Explicitly dispose of the agent before destructing to ensure
     // same behavior (and correctness) with and without Oilpan.
-    ClientMessageLoopAdapter::inspectedViewClosed(m_webViewImpl);
     if (m_attached)
         Platform::current()->currentThread()->removeTaskObserver(this);
 #if ENABLE(ASSERT)
     ASSERT(!m_hasBeenDisposed);
     m_hasBeenDisposed = true;
 #endif
 }
 
+// static
+void WebDevToolsAgentImpl::webViewImplClosed(WebViewImpl* webViewImpl)
+{
+    ClientMessageLoopAdapter::webViewImplClosed(webViewImpl);
+}
+
+// static
+void WebDevToolsAgentImpl::webFrameWidgetImplClosed(WebFrameWidgetImpl* webFrameWidgetImpl)
+{
+    ClientMessageLoopAdapter::webFrameWidgetImplClosed(webFrameWidgetImpl);
+}
+
 DEFINE_TRACE(WebDevToolsAgentImpl)
 {
     visitor->trace(m_instrumentingAgents);
     visitor->trace(m_injectedScriptManager);
     visitor->trace(m_state);
     visitor->trace(m_overlay);
     visitor->trace(m_asyncCallTracker);
     visitor->trace(m_domAgent);
     visitor->trace(m_pageAgent);
     visitor->trace(m_cssAgent);
@@ skipping 118 matching lines @@
     // Release overlay resources.
     m_overlay->clear();
     InspectorInstrumentation::frontendDeleted();
     InspectorInstrumentation::unregisterInstrumentingAgents(m_instrumentingAgents.get());
 
     m_attached = false;
 }
 
 void WebDevToolsAgentImpl::continueProgram()
 {
-    ClientMessageLoopAdapter::didNavigate();
+    ClientMessageLoopAdapter::continueProgram();
 }
 
 bool WebDevToolsAgentImpl::handleInputEvent(Page* page, const WebInputEvent& inputEvent)
 {
     if (!m_attached)
         return false;
 
     if (WebInputEvent::isGestureEventType(inputEvent.type) && inputEvent.type == WebInputEvent::GestureTap) {
         // Only let GestureTab in (we only need it and we know PlatformGestureEventBuilder supports it).
         PlatformGestureEvent gestureEvent = PlatformGestureEventBuilder(page->deprecatedLocalMainFrame()->view(), static_cast<const WebGestureEvent&>(inputEvent));
@@ skipping 219 matching lines @@
     if (!InspectorBackendDispatcher::getCommandName(message, &commandName))
         return false;
     return commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_pauseCmd)
         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_setBreakpointCmd)
         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_setBreakpointByUrlCmd)
         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_removeBreakpointCmd)
         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_setBreakpointsActiveCmd);
 }
 
 } // namespace blink