Replacing most of web_task.h with base::Closure + base::WeakPtrFactory.

components/test_runner/test_runner.h

 // Copyright 2014 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.
 
 #ifndef COMPONENTS_TEST_RUNNER_TEST_RUNNER_H_
 #define COMPONENTS_TEST_RUNNER_TEST_RUNNER_H_
 
 #include <stdint.h>
 
 #include <deque>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "components/test_runner/layout_test_runtime_flags.h"
 #include "components/test_runner/test_runner_export.h"
-#include "components/test_runner/web_task.h"
 #include "components/test_runner/web_test_runner.h"
 #include "third_party/WebKit/public/platform/WebImage.h"
 #include "v8/include/v8.h"
 
 class GURL;
 class SkBitmap;
 
 namespace blink {
 class WebContentSettingsClient;
 class WebFrame;
@@ skipping 14 matching lines @@
 class MockCredentialManagerClient;
 class MockScreenOrientationClient;
 class MockWebSpeechRecognizer;
 class MockWebUserMediaClient;
 class SpellCheckClient;
 class TestInterfaces;
 class WebContentSettings;
 class WebTestDelegate;
 class WebTestProxyBase;
 
-class TestRunner : public WebTestRunner,
-                   public base::SupportsWeakPtr<TestRunner> {
+class TestRunner : public WebTestRunner {
  public:
   explicit TestRunner(TestInterfaces*);
   virtual ~TestRunner();
 
   void Install(blink::WebFrame* frame);
 
   void SetDelegate(WebTestDelegate*);
   void SetWebView(blink::WebView*, WebTestProxyBase*);
 
   void Reset();
 
-  WebTaskList* mutable_task_list() { return &task_list_; }
-
   void SetTestIsRunning(bool);
   bool TestIsRunning() const { return test_is_running_; }
 
   bool UseMockTheme() const { return use_mock_theme_; }
 
-  void InvokeCallback(scoped_ptr<InvokeCallbackTask> callback);
-
   // WebTestRunner implementation.
   bool ShouldGeneratePixelResults() override;
   bool ShouldDumpAsAudio() const override;
   void GetAudioData(std::vector<unsigned char>* buffer_view) const override;
   bool IsRecursiveLayoutDumpRequested() override;
   std::string DumpLayout(blink::WebLocalFrame* frame) override;
   void DumpPixelsAsync(
       blink::WebView* web_view,
       const base::Callback<void(const SkBitmap&)>& callback) override;
   void ReplicateLayoutTestRuntimeFlagsChanges(
@@ skipping 64 matching lines @@
   // A single item in the work queue.
   class WorkItem {
    public:
     virtual ~WorkItem() {}
 
     // Returns true if this started a load.
     virtual bool Run(WebTestDelegate*, blink::WebView*) = 0;
   };
 
  private:
-  friend class InvokeCallbackTask;
   friend class TestRunnerBindings;
   friend class WorkQueue;
 
+  // Helpers for working with base and V8 callbacks.
+  void PostTask(const base::Closure& callback);
+  void PostDelayedTask(long long delay, const base::Closure& callback);
+  void PostV8Callback(const v8::Local<v8::Function>& callback);
+  void PostV8CallbackWithArgs(v8::UniquePersistent<v8::Function> callback,
+                              int argc,
+                              v8::Local<v8::Value> argv[]);
+  void InvokeV8Callback(const v8::UniquePersistent<v8::Function>& callback);
+  void InvokeV8CallbackWithArgs(
+      const v8::UniquePersistent<v8::Function>& callback,
+      const std::vector<v8::UniquePersistent<v8::Value>>& args);
+  base::Closure CreateClosureThatPostsV8Callback(
+      const v8::Local<v8::Function>& callback);
+
   // Helper class for managing events queued by methods like queueLoad or
   // queueScript.
   class WorkQueue {
    public:
     explicit WorkQueue(TestRunner* controller);
     virtual ~WorkQueue();
     void ProcessWorkSoon();
 
     // Reset the state of the class between tests.
     void Reset();
 
     void AddWork(WorkItem*);
 
     void set_frozen(bool frozen) { frozen_ = frozen; }
     bool is_empty() { return queue_.empty(); }
-    WebTaskList* mutable_task_list() { return &task_list_; }
 
    private:
     void ProcessWork();
 
-    class WorkQueueTask : public WebMethodTask<WorkQueue> {
-     public:
-      WorkQueueTask(WorkQueue* object) : WebMethodTask<WorkQueue>(object) {}
-
-      void RunIfValid() override;
-    };
-
-    WebTaskList task_list_;
     std::deque<WorkItem*> queue_;
     bool frozen_;
     TestRunner* controller_;
+
+    base::WeakPtrFactory<WorkQueue> weak_factory_;
   };
 
   ///////////////////////////////////////////////////////////////////////////
   // Methods dealing with the test logic
 
   // By default, tests end when page load is complete. These methods are used
   // to delay the completion of the test until notifyDone is called.
   void NotifyDone();
   void WaitUntilDone();
 
@@ skipping 440 matching lines @@
 
   void GetManifestThen(v8::Local<v8::Function> callback);
 
   // Takes care of notifying the delegate after a change to layout test runtime
   // flags.
   void OnLayoutTestRuntimeFlagsChanged();
 
   ///////////////////////////////////////////////////////////////////////////
   // Internal helpers
 
-  void GetManifestCallback(scoped_ptr<InvokeCallbackTask> task,
+  void GetManifestCallback(v8::UniquePersistent<v8::Function> callback,
                            const blink::WebURLResponse& response,
                            const std::string& data);
-  void CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,
+  void CapturePixelsCallback(v8::UniquePersistent<v8::Function> callback,
                              const SkBitmap& snapshot);
-  void DispatchBeforeInstallPromptCallback(scoped_ptr<InvokeCallbackTask> task,
-                                           bool canceled);
+  void DispatchBeforeInstallPromptCallback(
+      v8::UniquePersistent<v8::Function> callback,
+      bool canceled);
   void GetBluetoothManualChooserEventsCallback(
-      scoped_ptr<InvokeCallbackTask> task,
+      v8::UniquePersistent<v8::Function> callback,
       const std::vector<std::string>& events);
 
   void CheckResponseMimeType();
   void CompleteNotifyDone();
 
   void DidAcquirePointerLockInternal();
   void DidNotAcquirePointerLockInternal();
   void DidLosePointerLockInternal();
 
   // In the Mac code, this is called to trigger the end of a test after the
@@ skipping 112 matching lines @@
   bool should_dump_resource_priorities_;
 
   bool has_custom_text_output_;
   std::string custom_text_output_;
 
   std::set<std::string> http_headers_to_clear_;
 
   // WAV audio data is stored here.
   std::vector<unsigned char> audio_data_;
 
-  // Used for test timeouts.
-  WebTaskList task_list_;
-
   TestInterfaces* test_interfaces_;
   WebTestDelegate* delegate_;
   blink::WebView* web_view_;
   WebTestProxyBase* proxy_;
 
   // This is non-0 IFF a load is in progress.
   blink::WebFrame* top_loading_frame_;
 
   // WebContentSettingsClient mock object.
   scoped_ptr<WebContentSettings> web_content_settings_;
@@ skipping 21 matching lines @@
   std::set<blink::WebView*> views_with_scheduled_animations_;
 
   base::WeakPtrFactory<TestRunner> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRunner);
 };
 
 }  // namespace test_runner
 
 #endif  // COMPONENTS_TEST_RUNNER_TEST_RUNNER_H_