More v8-API-related cleanup.

content/renderer/skia_benchmarking_extension.cc

 // Copyright (c) 2013 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/skia_benchmarking_extension.h"
 
 #include "base/base64.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
@@ skipping 204 matching lines @@
     for (size_t i = 0; i < bitmap.getSize(); i += 4) {
         uint32 c = packed_pixels[i >> 2];
         buffer_pixels[i]     = SkGetPackedR32(c);
         buffer_pixels[i + 1] = SkGetPackedG32(c);
         buffer_pixels[i + 2] = SkGetPackedB32(c);
         buffer_pixels[i + 3] = SkGetPackedA32(c);
     }
 
     v8::Handle<v8::Object> result = v8::Object::New(isolate);
     result->Set(v8::String::NewFromUtf8(isolate, "width"),
-                v8::Number::New(snapped_clip.width()));
+                v8::Number::New(isolate, snapped_clip.width()));
     result->Set(v8::String::NewFromUtf8(isolate, "height"),
-                v8::Number::New(snapped_clip.height()));
+                v8::Number::New(isolate, snapped_clip.height()));
     result->Set(v8::String::NewFromUtf8(isolate, "data"), buffer.toV8Value());
 
     args.GetReturnValue().Set(result);
   }
 
   static void GetOps(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 1)
       return;
 
     v8::Isolate* isolate = args.GetIsolate();
@@ skipping 55 matching lines @@
     base::TimeDelta total_time = base::TimeTicks::HighResNow() - t0;
 
     // Gather per-op timing info by drawing into a BenchmarkingCanvas.
     skia::BenchmarkingCanvas benchmarking_canvas(bounds.width(),
                                                  bounds.height());
     picture->Replay(&benchmarking_canvas);
 
     v8::Local<v8::Array> op_times =
         v8::Array::New(isolate, benchmarking_canvas.CommandCount());
     for (size_t i = 0; i < benchmarking_canvas.CommandCount(); ++i)
-        op_times->Set(i, v8::Number::New(benchmarking_canvas.GetTime(i)));
+        op_times->Set(i, v8::Number::New(isolate,
+                                         benchmarking_canvas.GetTime(i)));
 
     v8::Handle<v8::Object> result = v8::Object::New(isolate);
     result->Set(v8::String::NewFromUtf8(isolate, "total_time"),
-                v8::Number::New(total_time.InMillisecondsF()));
+                v8::Number::New(isolate, total_time.InMillisecondsF()));
     result->Set(v8::String::NewFromUtf8(isolate, "cmd_times"), op_times);
 
     args.GetReturnValue().Set(result);
   }
 
   static void GetInfo(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 1)
       return;
 
     v8::Isolate* isolate = args.GetIsolate();
     scoped_refptr<cc::Picture> picture = ParsePictureStr(isolate, args[0]);
     if (!picture.get())
       return;
 
     v8::Handle<v8::Object> result = v8::Object::New(isolate);
     result->Set(v8::String::NewFromUtf8(isolate, "width"),
-                v8::Number::New(picture->LayerRect().width()));
+                v8::Number::New(isolate, picture->LayerRect().width()));
     result->Set(v8::String::NewFromUtf8(isolate, "height"),
-                v8::Number::New(picture->LayerRect().height()));
+                v8::Number::New(isolate, picture->LayerRect().height()));
 
     args.GetReturnValue().Set(result);
   }
 };
 
 } // namespace
 
 namespace content {
 
 v8::Extension* SkiaBenchmarkingExtension::Get() {
   return new SkiaBenchmarkingWrapper();
 }
 
 void SkiaBenchmarkingExtension::InitSkGraphics() {
     // Always call on the main render thread.
     // Does not need to be thread-safe, as long as the above holds.
     // FIXME: remove this after Skia updates SkGraphics::Init() to be
     //        thread-safe and idempotent.
     static bool skia_initialized = false;
     if (!skia_initialized) {
       SkGraphics::Init();
       skia_initialized = true;
     }
 }
 
 } // namespace content