Replacing v8::Handle with v8::Local in src/net

net/proxy/proxy_resolver_v8.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 "net/proxy/proxy_resolver_v8.h"
 
 #include <algorithm>
 #include <cstdio>
 
 #include "base/basictypes.h"
@@ skipping 115 matching lines @@
 };
 
 // When creating a v8::String from a C++ string we have two choices: create
 // a copy, or create a wrapper that shares the same underlying storage.
 // For small strings it is better to just make a copy, whereas for large
 // strings there are savings by sharing the storage. This number identifies
 // the cutoff length for when to start wrapping rather than creating copies.
 const size_t kMaxStringBytesForCopy = 256;
 
 // Converts a V8 String to a UTF8 std::string.
-std::string V8StringToUTF8(v8::Handle<v8::String> s) {
+std::string V8StringToUTF8(v8::Local<v8::String> s) {
   int len = s->Length();
   std::string result;
   if (len > 0)
     s->WriteUtf8(WriteInto(&result, len + 1));
   return result;
 }
 
 // Converts a V8 String to a UTF16 base::string16.
-base::string16 V8StringToUTF16(v8::Handle<v8::String> s) {
+base::string16 V8StringToUTF16(v8::Local<v8::String> s) {
   int len = s->Length();
   base::string16 result;
   // Note that the reinterpret cast is because on Windows string16 is an alias
   // to wstring, and hence has character type wchar_t not uint16_t.
   if (len > 0)
     s->Write(reinterpret_cast<uint16_t*>(WriteInto(&result, len + 1)), 0, len);
   return result;
 }
 
 // Converts an ASCII std::string to a V8 string.
@@ skipping 26 matching lines @@
   size_t length = strlen(ascii);
   if (length <= kMaxStringBytesForCopy)
     return v8::String::NewFromUtf8(isolate, ascii, v8::String::kNormalString,
                                    length);
   return v8::String::NewExternal(isolate,
                                  new V8ExternalASCIILiteral(ascii, length));
 }
 
 // Stringizes a V8 object by calling its toString() method. Returns true
 // on success. This may fail if the toString() throws an exception.
-bool V8ObjectToUTF16String(v8::Handle<v8::Value> object,
+bool V8ObjectToUTF16String(v8::Local<v8::Value> object,
                            base::string16* utf16_result,
                            v8::Isolate* isolate) {
   if (object.IsEmpty())
     return false;
 
   v8::HandleScope scope(isolate);
   v8::Local<v8::String> str_object = object->ToString();
   if (str_object.IsEmpty())
     return false;
   *utf16_result = V8StringToUTF16(str_object);
@@ skipping 163 matching lines @@
         v8::Local<v8::Context>::New(isolate_, v8_context_);
     v8::Context::Scope function_scope(context);
 
     v8::Local<v8::Value> function;
     if (!GetFindProxyForURL(&function)) {
       js_bindings()->OnError(
           -1, base::ASCIIToUTF16("FindProxyForURL() is undefined."));
       return ERR_PAC_SCRIPT_FAILED;
     }
 
-    v8::Handle<v8::Value> argv[] = {
+    v8::Local<v8::Value> argv[] = {
       ASCIIStringToV8String(isolate_, query_url.spec()),
       ASCIIStringToV8String(isolate_, query_url.HostNoBrackets()),
     };
 
     v8::TryCatch try_catch;
     v8::Local<v8::Value> ret = v8::Function::Cast(*function)->Call(
         context->Global(), arraysize(argv), argv);
 
     if (try_catch.HasCaught()) {
       HandleError(try_catch.Message());
@@ skipping 118 matching lines @@
   bool GetFindProxyForURL(v8::Local<v8::Value>* function) {
     v8::Local<v8::Context> context =
         v8::Local<v8::Context>::New(isolate_, v8_context_);
     *function =
         context->Global()->Get(
             ASCIILiteralToV8String(isolate_, "FindProxyForURL"));
     return (*function)->IsFunction();
   }
 
   // Handle an exception thrown by V8.
-  void HandleError(v8::Handle<v8::Message> message) {
+  void HandleError(v8::Local<v8::Message> message) {
     base::string16 error_message;
     int line_number = -1;
 
     if (!message.IsEmpty()) {
       line_number = message->GetLineNumber();
       V8ObjectToUTF16String(message->Get(), &error_message, isolate_);
     }
 
     js_bindings()->OnError(line_number, error_message);
   }
 
   // Compiles and runs |script| in the current V8 context.
   // Returns OK on success, otherwise an error code.
-  int RunScript(v8::Handle<v8::String> script, const char* script_name) {
+  int RunScript(v8::Local<v8::String> script, const char* script_name) {
     v8::TryCatch try_catch;
 
     // Compile the script.
     v8::ScriptOrigin origin =
         v8::ScriptOrigin(ASCIILiteralToV8String(isolate_, script_name));
     v8::Local<v8::Script> code = v8::Script::Compile(script, &origin);
 
     // Execute.
     if (!code.IsEmpty())
       code->Run();
@@ skipping 257 matching lines @@
     return 0;
 
   v8::Locker locked(g_proxy_resolver_isolate_->isolate());
   v8::Isolate::Scope isolate_scope(g_proxy_resolver_isolate_->isolate());
   v8::HeapStatistics heap_statistics;
   g_proxy_resolver_isolate_->isolate()->GetHeapStatistics(&heap_statistics);
   return heap_statistics.used_heap_size();
 }
 
 }  // namespace net