Enable message delivering in inspector-protocol tests when on pause

Source/core/testing/InspectorFrontendClientLocal.cpp

 /*
  * Copyright (C) 2010 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 19 matching lines @@
 
 #include "config.h"
 #include "InspectorFrontendClientLocal.h"
 
 #include "bindings/v8/ScriptObject.h"
 #include "core/inspector/InspectorController.h"
 #include "core/inspector/InspectorFrontendHost.h"
 #include "core/page/Page.h"
 #include "core/page/Settings.h"
 #include "core/platform/Timer.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebThread.h"
 #include <wtf/Deque.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
-class InspectorBackendDispatchTask {
+class InspectorBackendDispatchTask : public RefCounted<InspectorBackendDispatchTask> {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     InspectorBackendDispatchTask(InspectorController* inspectorController)

[yurys, 2013/07/16 06:56:18]

While you're here, pleas mark this constructor as explicit.

[Peter.Rybin, 2013/07/16 11:34:31]

Done.

-        : m_inspectorController(inspectorController)
-        , m_timer(this, &InspectorBackendDispatchTask::onTimer)
+        : m_inspectorController(inspectorController), m_stopped(false)
     {
     }
 
-    void dispatch(const String& message)
+    void dispatch(PassRefPtr<InspectorBackendDispatchTask> selfRef, const String& message)
     {
+        ASSERT(!m_stopped);
         m_messages.append(message);
-        if (!m_timer.isActive())
-            m_timer.startOneShot(0);
+        schedule(selfRef);
     }
 
-    void reset()
+    void stop()
     {
         m_messages.clear();

[yurys, 2013/07/16 06:56:18]

m_stopped = true is missing also I'd rather set m_inspectorController to 0, that
way we would also avoid keeping pointer on a potentially dead object.

[Peter.Rybin, 2013/07/16 11:34:31]

Done.

-        m_timer.stop();
     }
 
-    void onTimer(Timer<InspectorBackendDispatchTask>*)
+private:
+    void schedule(PassRefPtr<InspectorBackendDispatchTask> selfRef)

[yurys, 2013/07/16 06:56:18]

Why not use this and get rid of selfRef parameter?

[Peter.Rybin, 2013/07/16 09:59:02]

I'm not sure if it's fine to convert raw this to RefPtr (without any adopt or
similar things).
I thought this way it's more elegant.

[yurys, 2013/07/16 10:15:55]

That's absolutely fine to assign raw pointer to RefPtr. See for example
https://code.google.com/p/chromium/codesearch#search/&q=RefPtr.*protect&sq=pa...


The idea of adoptRef/adoptPtr is to have each object created with new
immediately wrapped into a smart pointer. Also we could enforce with presubmit
check use of adopt wherever 'new' is called.

[Peter.Rybin, 2013/07/16 11:34:31]

Done.

     {
+        class TaskImpl : public WebKit::WebThread::Task {
+        public:
+            RefPtr<InspectorBackendDispatchTask> owner;
+            virtual void run()
+            {
+                owner->deliver(owner);
+            }
+        };
+        TaskImpl* taskImpl = new TaskImpl;
+        taskImpl->owner = selfRef;
+        WebKit::Platform::current()->currentThread()->postTask(taskImpl);
+    }
+
+    void deliver(PassRefPtr<InspectorBackendDispatchTask> selfRef)
+    {
+        if (m_stopped)
+            return;
         if (!m_messages.isEmpty()) {
             // Dispatch can lead to the timer destruction -> schedule the next shot first.
-            m_timer.startOneShot(0);
+            schedule(selfRef);
             m_inspectorController->dispatchMessageFromFrontend(m_messages.takeFirst());
         }
     }
 
-private:
     InspectorController* m_inspectorController;
-    Timer<InspectorBackendDispatchTask> m_timer;
     Deque<String> m_messages;
+    bool m_stopped;
 };
 
 InspectorFrontendClientLocal::InspectorFrontendClientLocal(InspectorController* inspectorController, Page* frontendPage)
     : m_inspectorController(inspectorController)
     , m_frontendPage(frontendPage)
 {
     m_frontendPage->settings()->setAllowFileAccessFromFileURLs(true);
-    m_dispatchTask = adoptPtr(new InspectorBackendDispatchTask(inspectorController));
+    m_dispatchQueue = adoptRef(new InspectorBackendDispatchTask(inspectorController));
 }
 
 InspectorFrontendClientLocal::~InspectorFrontendClientLocal()
 {
+    m_dispatchQueue->stop();
     if (m_frontendHost)
         m_frontendHost->disconnectClient();
     m_frontendPage = 0;
     m_inspectorController = 0;
 }
 
 void InspectorFrontendClientLocal::windowObjectCleared()
 {
     if (m_frontendHost)
         m_frontendHost->disconnectClient();
     ScriptState* frontendScriptState = mainWorldScriptState(m_frontendPage->mainFrame());
     m_frontendHost = InspectorFrontendHost::create(this, m_frontendPage);
     ScriptGlobalObject::set(frontendScriptState, "InspectorFrontendHost", m_frontendHost.get());
 }
 
 void InspectorFrontendClientLocal::sendMessageToBackend(const String& message)
 {
-    m_dispatchTask->dispatch(message);
+    m_dispatchQueue->dispatch(m_dispatchQueue, message);
 }
 
 } // namespace WebCore