Use Local instead of Handle in src/content/*

content/renderer/pepper/v8_var_converter.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/pepper/v8_var_converter.h"
 
 #include <map>
 #include <stack>
 #include <string>
 
@@ skipping 26 matching lines @@
 
 template <class T>
 struct StackEntry {
   StackEntry(T v) : val(v), sentinel(false) {}
   T val;
   // Used to track parent nodes on the stack while traversing the graph.
   bool sentinel;
 };
 
 struct HashedHandle {
-  HashedHandle(v8::Handle<v8::Object> h) : handle(h) {}
+  HashedHandle(v8::Local<v8::Object> h) : handle(h) {}
   size_t hash() const { return handle->GetIdentityHash(); }
   bool operator==(const HashedHandle& h) const { return handle == h.handle; }
-  v8::Handle<v8::Object> handle;
+  v8::Local<v8::Object> handle;
 };
 
 }  // namespace
 
 namespace BASE_HASH_NAMESPACE {
 template <>
 struct hash<HashedHandle> {
   size_t operator()(const HashedHandle& handle) const { return handle.hash(); }
 };
 }  // namespace BASE_HASH_NAMESPACE
 
 namespace content {
 
 namespace {
 
 // Maps PP_Var IDs to the V8 value handle they correspond to.
-typedef base::hash_map<int64_t, v8::Handle<v8::Value> > VarHandleMap;
+typedef base::hash_map<int64_t, v8::Local<v8::Value> > VarHandleMap;
 typedef base::hash_set<int64_t> ParentVarSet;
 
 // Maps V8 value handles to the PP_Var they correspond to.
 typedef base::hash_map<HashedHandle, ScopedPPVar> HandleVarMap;
 typedef base::hash_set<HashedHandle> ParentHandleSet;
 
 // Returns a V8 value which corresponds to a given PP_Var. If |var| is a
 // reference counted PP_Var type, and it exists in |visited_ids|, the V8 value
 // associated with it in the map will be returned, otherwise a new V8 value will
 // be created and added to the map. |did_create| indicates whether a new v8
 // value was created as a result of calling the function.
-bool GetOrCreateV8Value(v8::Handle<v8::Context> context,
+bool GetOrCreateV8Value(v8::Local<v8::Context> context,
                         const PP_Var& var,
                         V8VarConverter::AllowObjectVars object_vars_allowed,
-                        v8::Handle<v8::Value>* result,
+                        v8::Local<v8::Value>* result,
                         bool* did_create,
                         VarHandleMap* visited_ids,
                         ParentVarSet* parent_ids,
                         ResourceConverter* resource_converter) {
   v8::Isolate* isolate = context->GetIsolate();
   *did_create = false;
 
   if (ppapi::VarTracker::IsVarTypeRefcounted(var.type)) {
     if (parent_ids->count(var.value.as_id) != 0)
       return false;
@@ skipping 87 matching lines @@
   if (ppapi::VarTracker::IsVarTypeRefcounted(var.type))
     (*visited_ids)[var.value.as_id] = *result;
   return true;
 }
 
 // For a given V8 value handle, this returns a PP_Var which corresponds to it.
 // If the handle already exists in |visited_handles|, the PP_Var associated with
 // it will be returned, otherwise a new V8 value will be created and added to
 // the map. |did_create| indicates if a new PP_Var was created as a result of
 // calling the function.
-bool GetOrCreateVar(v8::Handle<v8::Value> val,
-                    v8::Handle<v8::Context> context,
+bool GetOrCreateVar(v8::Local<v8::Value> val,
+                    v8::Local<v8::Context> context,
                     PP_Instance instance,
                     V8VarConverter::AllowObjectVars object_vars_allowed,
                     PP_Var* result,
                     bool* did_create,
                     HandleVarMap* visited_handles,
                     ParentHandleSet* parent_handles,
                     ResourceConverter* resource_converter) {
   CHECK(!val.IsEmpty());
   *did_create = false;
 
@@ skipping 35 matching lines @@
     // 3) If the object is an array, return an ArrayVar.
     // 4) If the object can be converted to a resource, return the ResourceVar.
     // 5) Otherwise return a DictionaryVar.
     scoped_ptr<blink::WebArrayBuffer> web_array_buffer(
         blink::WebArrayBufferConverter::createFromV8Value(val, isolate));
     if (web_array_buffer.get()) {
       scoped_refptr<HostArrayBufferVar> buffer_var(
           new HostArrayBufferVar(*web_array_buffer));
       *result = buffer_var->GetPPVar();
     } else if (object_vars_allowed == V8VarConverter::kAllowObjectVars) {
-      v8::Handle<v8::Object> object = val.As<v8::Object>();
+      v8::Local<v8::Object> object = val.As<v8::Object>();
       *result = content::HostGlobals::Get()->
           host_var_tracker()->V8ObjectVarForV8Object(instance, object);
     } else if (val->IsArray()) {
       *result = (new ArrayVar())->GetPPVar();
     } else {
       bool was_resource;
       if (!resource_converter->FromV8Value(val.As<v8::Object>(), context,
                                            result, &was_resource))
         return false;
       if (!was_resource) {
@@ skipping 41 matching lines @@
 // iteration, the top node on the stack examined. If the node has not been
 // visited yet (i.e. sentinel == false) then it is added to the list of parents
 // which contains all of the nodes on the path from the start node to the
 // current node. Each of the current nodes children are examined. If they appear
 // in the list of parents it means we have a cycle and we return NULL.
 // Otherwise, if they can have children, we add them to the stack. If the
 // node at the top of the stack has already been visited, then we pop it off the
 // stack and erase it from the list of parents.
 // static
 bool V8VarConverter::ToV8Value(const PP_Var& var,
-                               v8::Handle<v8::Context> context,
-                               v8::Handle<v8::Value>* result) {
+                               v8::Local<v8::Context> context,
+                               v8::Local<v8::Value>* result) {
   v8::Context::Scope context_scope(context);
   v8::Isolate* isolate = context->GetIsolate();
   v8::EscapableHandleScope handle_scope(isolate);
 
   VarHandleMap visited_ids;
   ParentVarSet parent_ids;
 
   std::stack<StackEntry<PP_Var> > stack;
   stack.push(StackEntry<PP_Var>(var));
   v8::Local<v8::Value> root;
   bool is_root = true;
 
   while (!stack.empty()) {
     const PP_Var& current_var = stack.top().val;
-    v8::Handle<v8::Value> current_v8;
+    v8::Local<v8::Value> current_v8;
 
     if (stack.top().sentinel) {
       stack.pop();
       if (CanHaveChildren(current_var))
         parent_ids.erase(current_var.value.as_id);
       continue;
     } else {
       stack.top().sentinel = true;
     }
 
@@ skipping 16 matching lines @@
 
     // Add child nodes to the stack.
     if (current_var.type == PP_VARTYPE_ARRAY) {
       parent_ids.insert(current_var.value.as_id);
       ArrayVar* array_var = ArrayVar::FromPPVar(current_var);
       if (!array_var) {
         NOTREACHED();
         return false;
       }
       DCHECK(current_v8->IsArray());
-      v8::Handle<v8::Array> v8_array = current_v8.As<v8::Array>();
+      v8::Local<v8::Array> v8_array = current_v8.As<v8::Array>();
 
       for (size_t i = 0; i < array_var->elements().size(); ++i) {
         const PP_Var& child_var = array_var->elements()[i].get();
-        v8::Handle<v8::Value> child_v8;
+        v8::Local<v8::Value> child_v8;
         if (!GetOrCreateV8Value(context,
                                 child_var,
                                 object_vars_allowed_,
                                 &child_v8,
                                 &did_create,
                                 &visited_ids,
                                 &parent_ids,
                                 resource_converter_.get())) {
           return false;
         }
         if (did_create && CanHaveChildren(child_var))
           stack.push(child_var);
         v8::TryCatch try_catch;
         v8_array->Set(static_cast<uint32>(i), child_v8);
         if (try_catch.HasCaught()) {
           LOG(ERROR) << "Setter for index " << i << " threw an exception.";
           return false;
         }
       }
     } else if (current_var.type == PP_VARTYPE_DICTIONARY) {
       parent_ids.insert(current_var.value.as_id);
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
       if (!dict_var) {
         NOTREACHED();
         return false;
       }
       DCHECK(current_v8->IsObject());
-      v8::Handle<v8::Object> v8_object = current_v8.As<v8::Object>();
+      v8::Local<v8::Object> v8_object = current_v8.As<v8::Object>();
 
       for (DictionaryVar::KeyValueMap::const_iterator iter =
                dict_var->key_value_map().begin();
            iter != dict_var->key_value_map().end();
            ++iter) {
         const std::string& key = iter->first;
         const PP_Var& child_var = iter->second.get();
-        v8::Handle<v8::Value> child_v8;
+        v8::Local<v8::Value> child_v8;
         if (!GetOrCreateV8Value(context,
                                 child_var,
                                 object_vars_allowed_,
                                 &child_v8,
                                 &did_create,
                                 &visited_ids,
                                 &parent_ids,
                                 resource_converter_.get())) {
           return false;
         }
@@ skipping 11 matching lines @@
         }
       }
     }
   }
 
   *result = handle_scope.Escape(root);
   return true;
 }
 
 V8VarConverter::VarResult V8VarConverter::FromV8Value(
-    v8::Handle<v8::Value> val,
-    v8::Handle<v8::Context> context,
+    v8::Local<v8::Value> val,
+    v8::Local<v8::Context> context,
     const base::Callback<void(const ScopedPPVar&, bool)>& callback) {
   VarResult result;
   result.success = FromV8ValueInternal(val, context, &result.var);
   if (!result.success)
     resource_converter_->Reset();
   result.completed_synchronously = !resource_converter_->NeedsFlush();
   if (!result.completed_synchronously)
     resource_converter_->Flush(base::Bind(callback, result.var));
 
   return result;
 }
 
 bool V8VarConverter::FromV8ValueSync(
-    v8::Handle<v8::Value> val,
-    v8::Handle<v8::Context> context,
+    v8::Local<v8::Value> val,
+    v8::Local<v8::Context> context,
     ppapi::ScopedPPVar* result_var) {
   bool success = FromV8ValueInternal(val, context, result_var);
   if (!success || resource_converter_->NeedsFlush()) {
     resource_converter_->Reset();
     return false;
   }
   return true;
 }
 
 bool V8VarConverter::FromV8ValueInternal(
-    v8::Handle<v8::Value> val,
-    v8::Handle<v8::Context> context,
+    v8::Local<v8::Value> val,
+    v8::Local<v8::Context> context,
     ppapi::ScopedPPVar* result_var) {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope(context->GetIsolate());
 
   HandleVarMap visited_handles;
   ParentHandleSet parent_handles;
 
-  std::stack<StackEntry<v8::Handle<v8::Value> > > stack;
-  stack.push(StackEntry<v8::Handle<v8::Value> >(val));
+  std::stack<StackEntry<v8::Local<v8::Value> > > stack;
+  stack.push(StackEntry<v8::Local<v8::Value> >(val));
   ScopedPPVar root;
   *result_var = PP_MakeUndefined();
   bool is_root = true;
 
   while (!stack.empty()) {
-    v8::Handle<v8::Value> current_v8 = stack.top().val;
+    v8::Local<v8::Value> current_v8 = stack.top().val;
     PP_Var current_var;
 
     if (stack.top().sentinel) {
       stack.pop();
       if (current_v8->IsObject())
         parent_handles.erase(HashedHandle(current_v8.As<v8::Object>()));
       continue;
     } else {
       stack.top().sentinel = true;
     }
@@ skipping 12 matching lines @@
     }
 
     if (is_root) {
       is_root = false;
       root = current_var;
     }
 
     // Add child nodes to the stack.
     if (current_var.type == PP_VARTYPE_ARRAY) {
       DCHECK(current_v8->IsArray());
-      v8::Handle<v8::Array> v8_array = current_v8.As<v8::Array>();
+      v8::Local<v8::Array> v8_array = current_v8.As<v8::Array>();
       parent_handles.insert(HashedHandle(v8_array));
 
       ArrayVar* array_var = ArrayVar::FromPPVar(current_var);
       if (!array_var) {
         NOTREACHED();
         return false;
       }
 
       for (uint32 i = 0; i < v8_array->Length(); ++i) {
         v8::TryCatch try_catch;
-        v8::Handle<v8::Value> child_v8 = v8_array->Get(i);
+        v8::Local<v8::Value> child_v8 = v8_array->Get(i);
         if (try_catch.HasCaught())
           return false;
 
         if (!v8_array->HasRealIndexedProperty(i))
           continue;
 
         PP_Var child_var;
         if (!GetOrCreateVar(child_v8,
                             context,
                             instance_,
                             object_vars_allowed_,
                             &child_var,
                             &did_create,
                             &visited_handles,
                             &parent_handles,
                             resource_converter_.get())) {
           return false;
         }
         if (did_create && child_v8->IsObject())
           stack.push(child_v8);
 
         array_var->Set(i, child_var);
       }
     } else if (current_var.type == PP_VARTYPE_DICTIONARY) {
       DCHECK(current_v8->IsObject());
-      v8::Handle<v8::Object> v8_object = current_v8.As<v8::Object>();
+      v8::Local<v8::Object> v8_object = current_v8.As<v8::Object>();
       parent_handles.insert(HashedHandle(v8_object));
 
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
       if (!dict_var) {
         NOTREACHED();
         return false;
       }
 
-      v8::Handle<v8::Array> property_names(v8_object->GetOwnPropertyNames());
+      v8::Local<v8::Array> property_names(v8_object->GetOwnPropertyNames());
       for (uint32 i = 0; i < property_names->Length(); ++i) {
-        v8::Handle<v8::Value> key(property_names->Get(i));
+        v8::Local<v8::Value> key(property_names->Get(i));
 
         // Extend this test to cover more types as necessary and if sensible.
         if (!key->IsString() && !key->IsNumber()) {
           NOTREACHED() << "Key \"" << *v8::String::Utf8Value(key)
                        << "\" "
                           "is neither a string nor a number";
           return false;
         }
 
-        v8::Handle<v8::String> key_string =
+        v8::Local<v8::String> key_string =
             key->ToString(context->GetIsolate());
         // Skip all callbacks: crbug.com/139933
         if (v8_object->HasRealNamedCallbackProperty(key_string))
           continue;
 
         v8::String::Utf8Value name_utf8(key_string);
 
         v8::TryCatch try_catch;
-        v8::Handle<v8::Value> child_v8 = v8_object->Get(key);
+        v8::Local<v8::Value> child_v8 = v8_object->Get(key);
         if (try_catch.HasCaught())
           return false;
 
         PP_Var child_var;
         if (!GetOrCreateVar(child_v8,
                             context,
                             instance_,
                             object_vars_allowed_,
                             &child_var,
                             &did_create,
                             &visited_handles,
                             &parent_handles,
                             resource_converter_.get())) {
           return false;
         }
         if (did_create && child_v8->IsObject())
           stack.push(child_v8);
 
         bool success = dict_var->SetWithStringKey(
             std::string(*name_utf8, name_utf8.length()), child_var);
         DCHECK(success);
       }
     }
   }
   *result_var = root;
   return true;
 }
 
 }  // namespace content