Use Local instead of Handle in src/content/*

content/renderer/gpu/gpu_benchmarking_extension.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 "content/renderer/gpu/gpu_benchmarking_extension.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
@@ skipping 125 matching lines @@
   if (args->PeekNext()->IsUndefined()) {
     args->Skip();
     return true;
   }
   return GetArg(args, value);
 }
 
 class CallbackAndContext : public base::RefCounted<CallbackAndContext> {
  public:
   CallbackAndContext(v8::Isolate* isolate,
-                     v8::Handle<v8::Function> callback,
-                     v8::Handle<v8::Context> context)
+                     v8::Local<v8::Function> callback,
+                     v8::Local<v8::Context> context)
       : isolate_(isolate) {
     callback_.Reset(isolate_, callback);
     context_.Reset(isolate_, context);
   }
 
   v8::Isolate* isolate() {
     return isolate_;
   }
 
-  v8::Handle<v8::Function> GetCallback() {
+  v8::Local<v8::Function> GetCallback() {
     return v8::Local<v8::Function>::New(isolate_, callback_);
   }
 
-  v8::Handle<v8::Context> GetContext() {
+  v8::Local<v8::Context> GetContext() {
     return v8::Local<v8::Context>::New(isolate_, context_);
   }
 
  private:
   friend class base::RefCounted<CallbackAndContext>;
 
   virtual ~CallbackAndContext() {
     callback_.Reset();
     context_.Reset();
   }
@@ skipping 68 matching lines @@
   RenderWidgetCompositor* compositor_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuBenchmarkingContext);
 };
 
 void OnMicroBenchmarkCompleted(
     CallbackAndContext* callback_and_context,
     scoped_ptr<base::Value> result) {
   v8::Isolate* isolate = callback_and_context->isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::Context> context = callback_and_context->GetContext();
+  v8::Local<v8::Context> context = callback_and_context->GetContext();
   v8::Context::Scope context_scope(context);
   WebLocalFrame* frame = WebLocalFrame::frameForContext(context);
   if (frame) {
     scoped_ptr<V8ValueConverter> converter =
         make_scoped_ptr(V8ValueConverter::create());
-    v8::Handle<v8::Value> value = converter->ToV8Value(result.get(), context);
-    v8::Handle<v8::Value> argv[] = { value };
+    v8::Local<v8::Value> value = converter->ToV8Value(result.get(), context);
+    v8::Local<v8::Value> argv[] = { value };
 
     frame->callFunctionEvenIfScriptDisabled(
         callback_and_context->GetCallback(),
         v8::Object::New(isolate),
         1,
         argv);
   }
 }
 
 void OnSyntheticGestureCompleted(CallbackAndContext* callback_and_context) {
   v8::Isolate* isolate = callback_and_context->isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::Context> context = callback_and_context->GetContext();
+  v8::Local<v8::Context> context = callback_and_context->GetContext();
   v8::Context::Scope context_scope(context);
   WebLocalFrame* frame = WebLocalFrame::frameForContext(context);
   if (frame) {
     frame->callFunctionEvenIfScriptDisabled(
         callback_and_context->GetCallback(), v8::Object::New(isolate), 0, NULL);
   }
 }
 
 bool BeginSmoothScroll(v8::Isolate* isolate,
                        float pixels_to_scroll,
-                       v8::Handle<v8::Function> callback,
+                       v8::Local<v8::Function> callback,
                        int gesture_source_type,
                        const std::string& direction,
                        float speed_in_pixels_s,
                        bool prevent_fling,
                        float start_x,
                        float start_y) {
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return false;
 
@@ skipping 56 matching lines @@
       base::Bind(&OnSyntheticGestureCompleted, callback_and_context));
 
   return true;
 }
 
 bool BeginSmoothDrag(v8::Isolate* isolate,
                      float start_x,
                      float start_y,
                      float end_x,
                      float end_y,
-                     v8::Handle<v8::Function> callback,
+                     v8::Local<v8::Function> callback,
                      int gesture_source_type,
                      float speed_in_pixels_s) {
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return false;
   scoped_refptr<CallbackAndContext> callback_and_context =
       new CallbackAndContext(isolate, callback,
                              context.web_frame()->mainWorldScriptContext());
 
   scoped_ptr<SyntheticSmoothDragGestureParams> gesture_params(
@@ skipping 24 matching lines @@
 }
 
 }  // namespace
 
 gin::WrapperInfo GpuBenchmarking::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 // static
 void GpuBenchmarking::Install(blink::WebFrame* frame) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
+  v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
 
   gin::Handle<GpuBenchmarking> controller =
       gin::CreateHandle(isolate, new GpuBenchmarking());
   if (controller.IsEmpty())
     return;
 
-  v8::Handle<v8::Object> chrome = GetOrCreateChromeObject(isolate,
+  v8::Local<v8::Object> chrome = GetOrCreateChromeObject(isolate,
                                                           context->Global());
   chrome->Set(gin::StringToV8(isolate, "gpuBenchmarking"), controller.ToV8());
 }
 
 GpuBenchmarking::GpuBenchmarking() {
 }
 
 GpuBenchmarking::~GpuBenchmarking() {
 }
 
@@ skipping 79 matching lines @@
 
 bool GpuBenchmarking::SmoothScrollBy(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return false;
 
   float page_scale_factor = context.web_view()->pageScaleFactor();
   blink::WebRect rect = context.render_view_impl()->windowRect();
 
   float pixels_to_scroll = 0;
-  v8::Handle<v8::Function> callback;
+  v8::Local<v8::Function> callback;
   float start_x = rect.width / (page_scale_factor * 2);
   float start_y = rect.height / (page_scale_factor * 2);
   int gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
   std::string direction = "down";
   float speed_in_pixels_s = 800;
 
   if (!GetOptionalArg(args, &pixels_to_scroll) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &start_x) ||
       !GetOptionalArg(args, &start_y) ||
@@ skipping 16 matching lines @@
 
 bool GpuBenchmarking::SmoothDrag(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return false;
 
   float start_x;
   float start_y;
   float end_x;
   float end_y;
-  v8::Handle<v8::Function> callback;
+  v8::Local<v8::Function> callback;
   int gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
   float speed_in_pixels_s = 800;
 
   if (!GetArg(args, &start_x) ||
       !GetArg(args, &start_y) ||
       !GetArg(args, &end_x) ||
       !GetArg(args, &end_y) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &gesture_source_type) ||
       !GetOptionalArg(args, &speed_in_pixels_s)) {
@@ skipping 13 matching lines @@
 bool GpuBenchmarking::Swipe(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return false;
 
   float page_scale_factor = context.web_view()->pageScaleFactor();
   blink::WebRect rect = context.render_view_impl()->windowRect();
 
   std::string direction = "up";
   float pixels_to_scroll = 0;
-  v8::Handle<v8::Function> callback;
+  v8::Local<v8::Function> callback;
   float start_x = rect.width / (page_scale_factor * 2);
   float start_y = rect.height / (page_scale_factor * 2);
   float speed_in_pixels_s = 800;
 
   if (!GetOptionalArg(args, &direction) ||
       !GetOptionalArg(args, &pixels_to_scroll) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &start_x) ||
       !GetOptionalArg(args, &start_y) ||
       !GetOptionalArg(args, &speed_in_pixels_s)) {
@@ skipping 16 matching lines @@
   if (!context.Init(false))
     return false;
 
   float page_scale_factor = context.web_view()->pageScaleFactor();
   blink::WebRect rect = context.render_view_impl()->windowRect();
 
   std::string direction = "down";
   float distance_length = 0;
   float overscroll_length = 0;
   int repeat_count = 1;
-  v8::Handle<v8::Function> callback;
+  v8::Local<v8::Function> callback;
   float start_x = rect.width / (page_scale_factor * 2);
   float start_y = rect.height / (page_scale_factor * 2);
   float speed_in_pixels_s = 800;
 
   if (!GetOptionalArg(args, &direction) ||
       !GetOptionalArg(args, &distance_length) ||
       !GetOptionalArg(args, &overscroll_length) ||
       !GetOptionalArg(args, &repeat_count) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &start_x) ||
@@ skipping 51 matching lines @@
 }
 
 bool GpuBenchmarking::PinchBy(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return false;
 
   float scale_factor;
   float anchor_x;
   float anchor_y;
-  v8::Handle<v8::Function> callback;
+  v8::Local<v8::Function> callback;
   float relative_pointer_speed_in_pixels_s = 800;
 
 
   if (!GetArg(args, &scale_factor) ||
       !GetArg(args, &anchor_x) ||
       !GetArg(args, &anchor_y) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &relative_pointer_speed_in_pixels_s)) {
     return false;
   }
@@ skipping 26 matching lines @@
   return true;
 }
 
 bool GpuBenchmarking::Tap(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return false;
 
   float position_x;
   float position_y;
-  v8::Handle<v8::Function> callback;
+  v8::Local<v8::Function> callback;
   int duration_ms = 50;
   int gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
 
   if (!GetArg(args, &position_x) ||
       !GetArg(args, &position_y) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &duration_ms) ||
       !GetOptionalArg(args, &gesture_source_type)) {
     return false;
   }
@@ skipping 34 matching lines @@
 void GpuBenchmarking::ClearImageCache() {
   WebImageCache::clear();
 }
 
 int GpuBenchmarking::RunMicroBenchmark(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return 0;
 
   std::string name;
-  v8::Handle<v8::Function> callback;
-  v8::Handle<v8::Object> arguments;
+  v8::Local<v8::Function> callback;
+  v8::Local<v8::Object> arguments;
 
   if (!GetArg(args, &name) || !GetArg(args, &callback) ||
       !GetOptionalArg(args, &arguments)) {
     return 0;
   }
 
   scoped_refptr<CallbackAndContext> callback_and_context =
       new CallbackAndContext(args->isolate(),
                              callback,
                              context.web_frame()->mainWorldScriptContext());
 
   scoped_ptr<V8ValueConverter> converter =
       make_scoped_ptr(V8ValueConverter::create());
-  v8::Handle<v8::Context> v8_context = callback_and_context->GetContext();
+  v8::Local<v8::Context> v8_context = callback_and_context->GetContext();
   scoped_ptr<base::Value> value =
       make_scoped_ptr(converter->FromV8Value(arguments, v8_context));
 
   return context.compositor()->ScheduleMicroBenchmark(
       name,
       value.Pass(),
       base::Bind(&OnMicroBenchmarkCompleted, callback_and_context));
 }
 
 bool GpuBenchmarking::SendMessageToMicroBenchmark(
     int id,
-    v8::Handle<v8::Object> message) {
+    v8::Local<v8::Object> message) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return false;
 
   scoped_ptr<V8ValueConverter> converter =
       make_scoped_ptr(V8ValueConverter::create());
-  v8::Handle<v8::Context> v8_context =
+  v8::Local<v8::Context> v8_context =
       context.web_frame()->mainWorldScriptContext();
   scoped_ptr<base::Value> value =
       make_scoped_ptr(converter->FromV8Value(message, v8_context));
 
   return context.compositor()->SendMessageToMicroBenchmark(id, value.Pass());
 }
 
 bool GpuBenchmarking::HasGpuProcess() {
     GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
     return !!gpu_channel;
 }
 
 }  // namespace content