Use Local instead of Handle in src/content/*

content/shell/renderer/test_runner/test_runner.cc

 // 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.
 
 #include "content/shell/renderer/test_runner/test_runner.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "content/public/test/layouttest_support.h"
@@ skipping 47 matching lines @@
 #if defined(__linux__) || defined(ANDROID)
 #include "third_party/WebKit/public/web/linux/WebFontRendering.h"
 #endif
 
 using namespace blink;
 
 namespace content {
 
 namespace {
 
-WebString V8StringToWebString(v8::Handle<v8::String> v8_str) {
+WebString V8StringToWebString(v8::Local<v8::String> v8_str) {
   int length = v8_str->Utf8Length() + 1;
   scoped_ptr<char[]> chars(new char[length]);
   v8_str->WriteUtf8(chars.get(), length);
   return WebString::fromUTF8(chars.get());
 }
 
 class HostMethodTask : public WebMethodTask<TestRunner> {
  public:
   typedef void (TestRunner::*CallbackMethodType)();
   HostMethodTask(TestRunner* object, CallbackMethodType callback)
       : WebMethodTask<TestRunner>(object), callback_(callback) {}
 
   void RunIfValid() override { (object_->*callback_)(); }
 
  private:
   CallbackMethodType callback_;
 };
 
 }  // namespace
 
 class InvokeCallbackTask : public WebMethodTask<TestRunner> {
  public:
-  InvokeCallbackTask(TestRunner* object, v8::Handle<v8::Function> callback)
+  InvokeCallbackTask(TestRunner* object, v8::Local<v8::Function> callback)
       : WebMethodTask<TestRunner>(object),
         callback_(blink::mainThreadIsolate(), callback),
         argc_(0) {}
 
   void RunIfValid() override {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     v8::HandleScope handle_scope(isolate);
     WebFrame* frame = object_->web_view_->mainFrame();
 
-    v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
+    v8::Local<v8::Context> context = frame->mainWorldScriptContext();
     if (context.IsEmpty())
       return;
 
     v8::Context::Scope context_scope(context);
 
-    scoped_ptr<v8::Handle<v8::Value>[]> local_argv;
+    scoped_ptr<v8::Local<v8::Value>[]> local_argv;
     if (argc_) {
-        local_argv.reset(new v8::Handle<v8::Value>[argc_]);
+        local_argv.reset(new v8::Local<v8::Value>[argc_]);
         for (int i = 0; i < argc_; ++i)
           local_argv[i] = v8::Local<v8::Value>::New(isolate, argv_[i]);
     }
 
     frame->callFunctionEvenIfScriptDisabled(
         v8::Local<v8::Function>::New(isolate, callback_),
         context->Global(),
         argc_,
         local_argv.get());
   }
 
-  void SetArguments(int argc, v8::Handle<v8::Value> argv[]) {
+  void SetArguments(int argc, v8::Local<v8::Value> argv[]) {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     argc_ = argc;
     argv_.reset(new v8::UniquePersistent<v8::Value>[argc]);
     for (int i = 0; i < argc; ++i)
       argv_[i] = v8::UniquePersistent<v8::Value>(isolate, argv[i]);
   }
 
  private:
   v8::UniquePersistent<v8::Function> callback_;
   int argc_;
@@ skipping 30 matching lines @@
   void WaitForPolicyDelegate();
   int WindowCount();
   void SetCloseRemainingWindowsWhenComplete(gin::Arguments* args);
   void ResetTestHelperControllers();
   void SetTabKeyCyclesThroughElements(bool tab_key_cycles_through_elements);
   void ExecCommand(gin::Arguments* args);
   bool IsCommandEnabled(const std::string& command);
   bool CallShouldCloseOnWebView();
   void SetDomainRelaxationForbiddenForURLScheme(bool forbidden,
                                                 const std::string& scheme);
-  v8::Handle<v8::Value> EvaluateScriptInIsolatedWorldAndReturnValue(
+  v8::Local<v8::Value> EvaluateScriptInIsolatedWorldAndReturnValue(
       int world_id, const std::string& script);
   void EvaluateScriptInIsolatedWorld(int world_id, const std::string& script);
   void SetIsolatedWorldSecurityOrigin(int world_id,
-                                      v8::Handle<v8::Value> origin);
+                                      v8::Local<v8::Value> origin);
   void SetIsolatedWorldContentSecurityPolicy(int world_id,
                                              const std::string& policy);
   void AddOriginAccessWhitelistEntry(const std::string& source_origin,
                                      const std::string& destination_protocol,
                                      const std::string& destination_host,
                                      bool allow_destination_subdomains);
   void RemoveOriginAccessWhitelistEntry(const std::string& source_origin,
                                         const std::string& destination_protocol,
                                         const std::string& destination_host,
                                         bool allow_destination_subdomains);
@@ skipping 25 matching lines @@
   void DidAcquirePointerLock();
   void DidNotAcquirePointerLock();
   void DidLosePointerLock();
   void SetPointerLockWillFailSynchronously();
   void SetPointerLockWillRespondAsynchronously();
   void SetPopupBlockingEnabled(bool block_popups);
   void SetJavaScriptCanAccessClipboard(bool can_access);
   void SetXSSAuditorEnabled(bool enabled);
   void SetAllowUniversalAccessFromFileURLs(bool allow);
   void SetAllowFileAccessFromFileURLs(bool allow);
-  void OverridePreference(const std::string key, v8::Handle<v8::Value> value);
+  void OverridePreference(const std::string key, v8::Local<v8::Value> value);
   void SetAcceptLanguages(const std::string& accept_languages);
   void SetPluginsEnabled(bool enabled);
   void DumpEditingCallbacks();
   void DumpAsMarkup();
   void DumpAsText();
   void DumpAsTextWithPixelResults();
   void DumpChildFrameScrollPositions();
   void DumpChildFramesAsMarkup();
   void DumpChildFramesAsText();
   void DumpIconChanges();
@@ skipping 31 matching lines @@
   void DumpNavigationPolicy();
   void ShowWebInspector(gin::Arguments* args);
   void CloseWebInspector();
   bool IsChooserShown();
   void EvaluateInWebInspector(int call_id, const std::string& script);
   void ClearAllDatabases();
   void SetDatabaseQuota(int quota);
   void SetAlwaysAcceptCookies(bool accept);
   void SetWindowIsKey(bool value);
   std::string PathToLocalResource(const std::string& path);
-  void SetBackingScaleFactor(double value, v8::Handle<v8::Function> callback);
+  void SetBackingScaleFactor(double value, v8::Local<v8::Function> callback);
   void SetColorProfile(const std::string& name,
-                       v8::Handle<v8::Function> callback);
+                       v8::Local<v8::Function> callback);
   void SetPOSIXLocale(const std::string& locale);
   void SetMIDIAccessorResult(bool result);
   void SimulateWebNotificationClick(const std::string& title);
   void AddMockSpeechRecognitionResult(const std::string& transcript,
                                       double confidence);
   void SetMockSpeechRecognitionError(const std::string& error,
                                      const std::string& message);
   bool WasMockSpeechRecognitionAborted();
   void AddMockCredentialManagerResponse(const std::string& id,
                                         const std::string& name,
                                         const std::string& avatar,
                                         const std::string& password);
   void AddWebPageOverlay();
   void RemoveWebPageOverlay();
   void DisplayAsync();
-  void DisplayAsyncThen(v8::Handle<v8::Function> callback);
-  void GetManifestThen(v8::Handle<v8::Function> callback);
-  void CapturePixelsAsyncThen(v8::Handle<v8::Function> callback);
+  void DisplayAsyncThen(v8::Local<v8::Function> callback);
+  void GetManifestThen(v8::Local<v8::Function> callback);
+  void CapturePixelsAsyncThen(v8::Local<v8::Function> callback);
   void CopyImageAtAndCapturePixelsAsyncThen(int x,
                                             int y,
-                                            v8::Handle<v8::Function> callback);
+                                            v8::Local<v8::Function> callback);
   void SetCustomTextOutput(std::string output);
   void SetViewSourceForFrame(const std::string& name, bool enabled);
   void SetBluetoothMockDataSet(const std::string& dataset_name);
   void SetGeofencingMockProvider(bool service_available);
   void ClearGeofencingMockProvider();
   void SetGeofencingMockPosition(double latitude, double longitude);
   void SetPermission(const std::string& name,
                      const std::string& value,
                      const std::string& origin,
                      const std::string& embedding_origin);
@@ skipping 405 matching lines @@
     return runner_->CallShouldCloseOnWebView();
   return false;
 }
 
 void TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme(
     bool forbidden, const std::string& scheme) {
   if (runner_)
     runner_->SetDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
 }
 
-v8::Handle<v8::Value>
+v8::Local<v8::Value>
 TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue(
     int world_id, const std::string& script) {
   if (!runner_)
-    return v8::Handle<v8::Value>();
+    return v8::Local<v8::Value>();
   return runner_->EvaluateScriptInIsolatedWorldAndReturnValue(world_id,
                                                               script);
 }
 
 void TestRunnerBindings::EvaluateScriptInIsolatedWorld(
     int world_id, const std::string& script) {
   if (runner_)
     runner_->EvaluateScriptInIsolatedWorld(world_id, script);
 }
 
 void TestRunnerBindings::SetIsolatedWorldSecurityOrigin(
-    int world_id, v8::Handle<v8::Value> origin) {
+    int world_id, v8::Local<v8::Value> origin) {
   if (runner_)
     runner_->SetIsolatedWorldSecurityOrigin(world_id, origin);
 }
 
 void TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy(
     int world_id, const std::string& policy) {
   if (runner_)
     runner_->SetIsolatedWorldContentSecurityPolicy(world_id, policy);
 }
 
@@ skipping 257 matching lines @@
   if (runner_)
     runner_->SetAllowUniversalAccessFromFileURLs(allow);
 }
 
 void TestRunnerBindings::SetAllowFileAccessFromFileURLs(bool allow) {
   if (runner_)
     runner_->SetAllowFileAccessFromFileURLs(allow);
 }
 
 void TestRunnerBindings::OverridePreference(const std::string key,
-                                            v8::Handle<v8::Value> value) {
+                                            v8::Local<v8::Value> value) {
   if (runner_)
     runner_->OverridePreference(key, value);
 }
 
 void TestRunnerBindings::SetAcceptLanguages(
     const std::string& accept_languages) {
   if (!runner_)
     return;
 
   runner_->SetAcceptLanguages(accept_languages);
@@ skipping 253 matching lines @@
     runner_->SetWindowIsKey(value);
 }
 
 std::string TestRunnerBindings::PathToLocalResource(const std::string& path) {
   if (runner_)
     return runner_->PathToLocalResource(path);
   return std::string();
 }
 
 void TestRunnerBindings::SetBackingScaleFactor(
-    double value, v8::Handle<v8::Function> callback) {
+    double value, v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->SetBackingScaleFactor(value, callback);
 }
 
 void TestRunnerBindings::SetColorProfile(
-    const std::string& name, v8::Handle<v8::Function> callback) {
+    const std::string& name, v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->SetColorProfile(name, callback);
 }
 
 void TestRunnerBindings::SetBluetoothMockDataSet(const std::string& name) {
   if (runner_)
     runner_->SetBluetoothMockDataSet(name);
 }
 
 void TestRunnerBindings::SetPOSIXLocale(const std::string& locale) {
@@ skipping 47 matching lines @@
 void TestRunnerBindings::RemoveWebPageOverlay() {
   if (runner_)
     runner_->RemoveWebPageOverlay();
 }
 
 void TestRunnerBindings::DisplayAsync() {
   if (runner_)
     runner_->DisplayAsync();
 }
 
-void TestRunnerBindings::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
+void TestRunnerBindings::DisplayAsyncThen(v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->DisplayAsyncThen(callback);
 }
 
-void TestRunnerBindings::GetManifestThen(v8::Handle<v8::Function> callback) {
+void TestRunnerBindings::GetManifestThen(v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->GetManifestThen(callback);
 }
 
 void TestRunnerBindings::CapturePixelsAsyncThen(
-    v8::Handle<v8::Function> callback) {
+    v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->CapturePixelsAsyncThen(callback);
 }
 
 void TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen(
-    int x, int y, v8::Handle<v8::Function> callback) {
+    int x, int y, v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback);
 }
 
 void TestRunnerBindings::SetCustomTextOutput(std::string output) {
   runner_->setCustomTextOutput(output);
 }
 
 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name,
                                                bool enabled) {
@@ skipping 747 matching lines @@
 bool TestRunner::CallShouldCloseOnWebView() {
   return web_view_->mainFrame()->dispatchBeforeUnloadEvent();
 }
 
 void TestRunner::SetDomainRelaxationForbiddenForURLScheme(
     bool forbidden, const std::string& scheme) {
   web_view_->setDomainRelaxationForbidden(forbidden,
                                           WebString::fromUTF8(scheme));
 }
 
-v8::Handle<v8::Value> TestRunner::EvaluateScriptInIsolatedWorldAndReturnValue(
+v8::Local<v8::Value> TestRunner::EvaluateScriptInIsolatedWorldAndReturnValue(
     int world_id,
     const std::string& script) {
   WebVector<v8::Local<v8::Value>> values;
   WebScriptSource source(WebString::fromUTF8(script));
   // This relies on the iframe focusing itself when it loads. This is a bit
   // sketchy, but it seems to be what other tests do.
   web_view_->focusedFrame()->executeScriptInIsolatedWorld(
       world_id, &source, 1, 1, &values);
   // Since only one script was added, only one result is expected
   if (values.size() == 1 && !values[0].IsEmpty())
     return values[0];
-  return v8::Handle<v8::Value>();
+  return v8::Local<v8::Value>();
 }
 
 void TestRunner::EvaluateScriptInIsolatedWorld(int world_id,
                                                const std::string& script) {
   WebScriptSource source(WebString::fromUTF8(script));
   web_view_->focusedFrame()->executeScriptInIsolatedWorld(
       world_id, &source, 1, 1);
 }
 
 void TestRunner::SetIsolatedWorldSecurityOrigin(int world_id,
-                                                v8::Handle<v8::Value> origin) {
+                                                v8::Local<v8::Value> origin) {
   if (!(origin->IsString() || !origin->IsNull()))
     return;
 
   WebSecurityOrigin web_origin;
   if (origin->IsString()) {
     web_origin = WebSecurityOrigin::createFromString(
         V8StringToWebString(origin.As<v8::String>()));
   }
   web_view_->focusedFrame()->setIsolatedWorldSecurityOrigin(world_id,
                                                             web_origin);
@@ skipping 294 matching lines @@
   delegate_->Preferences()->allow_universal_access_from_file_urls = allow;
   delegate_->ApplyPreferences();
 }
 
 void TestRunner::SetAllowFileAccessFromFileURLs(bool allow) {
   delegate_->Preferences()->allow_file_access_from_file_urls = allow;
   delegate_->ApplyPreferences();
 }
 
 void TestRunner::OverridePreference(const std::string key,
-                                    v8::Handle<v8::Value> value) {
+                                    v8::Local<v8::Value> value) {
   TestPreferences* prefs = delegate_->Preferences();
   if (key == "WebKitDefaultFontSize") {
     prefs->default_font_size = value->Int32Value();
   } else if (key == "WebKitMinimumFontSize") {
     prefs->minimum_font_size = value->Int32Value();
   } else if (key == "WebKitDefaultTextEncodingName") {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     prefs->default_text_encoding_name =
         V8StringToWebString(value->ToString(isolate));
   } else if (key == "WebKitJavaScriptEnabled") {
@@ skipping 253 matching lines @@
 
 void TestRunner::SetWindowIsKey(bool value) {
   delegate_->SetFocus(proxy_, value);
 }
 
 std::string TestRunner::PathToLocalResource(const std::string& path) {
   return delegate_->PathToLocalResource(path);
 }
 
 void TestRunner::SetBackingScaleFactor(double value,
-                                       v8::Handle<v8::Function> callback) {
+                                       v8::Local<v8::Function> callback) {
   delegate_->SetDeviceScaleFactor(value);
   delegate_->PostTask(new InvokeCallbackTask(this, callback));
 }
 
 void TestRunner::SetColorProfile(const std::string& name,
-                                 v8::Handle<v8::Function> callback) {
+                                 v8::Local<v8::Function> callback) {
   delegate_->SetDeviceColorProfile(name);
   delegate_->PostTask(new InvokeCallbackTask(this, callback));
 }
 
 void TestRunner::SetBluetoothMockDataSet(const std::string& name) {
   delegate_->SetBluetoothMockDataSet(name);
 }
 
 void TestRunner::SetGeofencingMockProvider(bool service_available) {
   delegate_->SetGeofencingMockProvider(service_available);
@@ skipping 65 matching lines @@
     web_view_->removePageOverlay(page_overlay_);
     delete page_overlay_;
     page_overlay_ = nullptr;
   }
 }
 
 void TestRunner::DisplayAsync() {
   proxy_->DisplayAsyncThen(base::Closure());
 }
 
-void TestRunner::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
+void TestRunner::DisplayAsyncThen(v8::Local<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
   proxy_->DisplayAsyncThen(base::Bind(&TestRunner::InvokeCallback,
                                       weak_factory_.GetWeakPtr(),
                                       base::Passed(&task)));
 }
 
-void TestRunner::GetManifestThen(v8::Handle<v8::Function> callback) {
+void TestRunner::GetManifestThen(v8::Local<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
 
   FetchManifest(web_view_, web_view_->mainFrame()->document().manifestURL(),
       base::Bind(&TestRunner::GetManifestCallback,
                  weak_factory_.GetWeakPtr(),
                  base::Passed(&task)));
 }
 
-void TestRunner::CapturePixelsAsyncThen(v8::Handle<v8::Function> callback) {
+void TestRunner::CapturePixelsAsyncThen(v8::Local<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
   proxy_->CapturePixelsAsync(base::Bind(&TestRunner::CapturePixelsCallback,
                                         weak_factory_.GetWeakPtr(),
                                         base::Passed(&task)));
 }
 
 void TestRunner::ForceNextWebGLContextCreationToFail() {
   if (web_view_)
     web_view_->forceNextWebGLContextCreationToFail();
 }
 
 void TestRunner::CopyImageAtAndCapturePixelsAsyncThen(
-    int x, int y, v8::Handle<v8::Function> callback) {
+    int x, int y, v8::Local<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
   proxy_->CopyImageAtAndCapturePixels(
       x, y, base::Bind(&TestRunner::CapturePixelsCallback,
                        weak_factory_.GetWeakPtr(),
                        base::Passed(&task)));
 }
 
 void TestRunner::GetManifestCallback(scoped_ptr<InvokeCallbackTask> task,
                                      const blink::WebURLResponse& response,
                                      const std::string& data) {
   InvokeCallback(task.Pass());
 }
 
 void TestRunner::CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,
                                        const SkBitmap& snapshot) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
 
-  v8::Handle<v8::Context> context =
+  v8::Local<v8::Context> context =
       web_view_->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
-  v8::Handle<v8::Value> argv[3];
+  v8::Local<v8::Value> argv[3];
   SkAutoLockPixels snapshot_lock(snapshot);
 
   // Size can be 0 for cases where copyImageAt was called on position
   // that doesn't have an image.
   int width = snapshot.info().fWidth;
   argv[0] = v8::Number::New(isolate, width);
 
   int height = snapshot.info().fHeight;
   argv[1] = v8::Number::New(isolate, height);
 
@@ skipping 66 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace content