Move v8 into third_party.

experimental/SkV8Example/Path.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  */
 
 #include "Path.h"
 #include "Global.h"
 
 Global* Path::gGlobal = NULL;
 
 void Path::ConstructPath(const v8::FunctionCallbackInfo<Value>& args) {
     HandleScope handleScope(gGlobal->getIsolate());
     Path* path = new Path();
-    args.This()->SetInternalField(0, External::New(path));
+    args.This()->SetInternalField(
+            0, External::New(gGlobal->getIsolate(), path));
 }
 
 #define ADD_METHOD(name, fn) \
     constructor->InstanceTemplate()->Set( \
             String::NewFromUtf8( \
                     global->getIsolate(), name, \
                     String::kInternalizedString), \
-            FunctionTemplate::New(fn))
+            FunctionTemplate::New(global->getIsolate(), fn))
 
 // Install the constructor in the global scope so Paths can be constructed
 // in JS.
 void Path::AddToGlobal(Global* global) {
     gGlobal = global;
 
     // Create a stack-allocated handle scope.
     HandleScope handleScope(gGlobal->getIsolate());
 
     Handle<Context> context = gGlobal->getContext();
 
     // Enter the scope so all operations take place in the scope.
     Context::Scope contextScope(context);
 
     Local<FunctionTemplate> constructor = FunctionTemplate::New(
-            Path::ConstructPath);
+            gGlobal->getIsolate(), Path::ConstructPath);
     constructor->InstanceTemplate()->SetInternalFieldCount(1);
 
     ADD_METHOD("close", ClosePath);
     ADD_METHOD("moveTo", MoveTo);
     ADD_METHOD("lineTo", LineTo);
     ADD_METHOD("quadraticCurveTo", QuadraticCurveTo);
     ADD_METHOD("bezierCurveTo", BezierCurveTo);
     ADD_METHOD("arc", Arc);
     ADD_METHOD("rect", Rect);
 
-    context->Global()->Set(String::New("Path"), constructor->GetFunction());
+    context->Global()->Set(String::NewFromUtf8(
+            gGlobal->getIsolate(), "Path"), constructor->GetFunction());
 }
 
 Path* Path::Unwrap(const v8::FunctionCallbackInfo<Value>& args) {
     Handle<External> field = Handle<External>::Cast(
             args.This()->GetInternalField(0));
     void* ptr = field->Value();
     return static_cast<Path*>(ptr);
 }
 
 void Path::ClosePath(const v8::FunctionCallbackInfo<Value>& args) {
@@ skipping 118 matching lines @@
 
     SkRect rect = {
         SkDoubleToScalar(x),
         SkDoubleToScalar(y),
         SkDoubleToScalar(x) + SkDoubleToScalar(w),
         SkDoubleToScalar(y) + SkDoubleToScalar(h)
     };
     Path* path = Unwrap(args);
     path->fSkPath.addRect(rect);
 }