Add PepperTryCatch and V8ObjectVar classes

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>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/host_array_buffer_var.h"
+#include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/resource_converter.h"
+#include "content/renderer/pepper/v8object_var.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/web/WebArrayBufferConverter.h"
 
 using ppapi::ArrayBufferVar;
 using ppapi::ArrayVar;
 using ppapi::DictionaryVar;
 using ppapi::ScopedPPVar;
 using ppapi::StringVar;
+using ppapi::V8ObjectVar;
 using std::make_pair;
 
 namespace {
 
 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;
@@ skipping 32 matching lines @@
 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,
                         const PP_Var& var,
+                        bool object_vars_allowed,
                         v8::Handle<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)
@@ skipping 50 matching lines @@
       *result = blink::WebArrayBufferConverter::toV8Value(
           &host_buffer->webkit_buffer(), context->Global(), isolate);
       break;
     }
     case PP_VARTYPE_ARRAY:
       *result = v8::Array::New(isolate);
       break;
     case PP_VARTYPE_DICTIONARY:
       *result = v8::Object::New(isolate);
       break;
-    case PP_VARTYPE_OBJECT:
-      result->Clear();
-      return false;
+    case PP_VARTYPE_OBJECT: {
+      DCHECK(object_vars_allowed);
+      scoped_refptr<V8ObjectVar> v8_object_var = V8ObjectVar::FromPPVar(var);
+      if (!v8_object_var) {
+        NOTREACHED();
+        result->Clear();
+        return false;
+      }
+      *result = v8_object_var->GetHandle();
+      break;
+    }
     case PP_VARTYPE_RESOURCE:
       if (!resource_converter->ToV8Value(var, context, result)) {
         result->Clear();
         return false;
       }
       break;
   }
 
   *did_create = true;
   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,
+                    PP_Instance instance,
+                    bool object_vars_allowed,
                     PP_Var* result,
                     bool* did_create,
                     HandleVarMap* visited_handles,
                     ParentHandleSet* parent_handles,
                     ResourceConverter* resource_converter) {
   CHECK(!val.IsEmpty());
   *did_create = false;
 
   // Even though every v8 string primitive encountered will be a unique object,
   // we still add them to |visited_handles| so that the corresponding string
   // PP_Var created will be properly refcounted.
   if (val->IsObject() || val->IsString()) {
     if (parent_handles->count(HashedHandle(val->ToObject())) != 0)
       return false;
 
     HandleVarMap::const_iterator it =
         visited_handles->find(HashedHandle(val->ToObject()));
     if (it != visited_handles->end()) {
       *result = it->second.get();
       return true;
     }
   }
 
+  v8::Isolate* isolate = context->GetIsolate();
   if (val->IsUndefined()) {
     *result = PP_MakeUndefined();
   } else if (val->IsNull()) {
     *result = PP_MakeNull();
   } else if (val->IsBoolean() || val->IsBooleanObject()) {
     *result = PP_MakeBool(PP_FromBool(val->ToBoolean()->Value()));
   } else if (val->IsInt32()) {
     *result = PP_MakeInt32(val->ToInt32()->Value());
   } else if (val->IsNumber() || val->IsNumberObject()) {
     *result = PP_MakeDouble(val->ToNumber()->Value());
   } else if (val->IsString() || val->IsStringObject()) {
     v8::String::Utf8Value utf8(val->ToString());
     *result = StringVar::StringToPPVar(std::string(*utf8, utf8.length()));
   } else if (val->IsArray()) {
     *result = (new ArrayVar())->GetPPVar();
   } else if (val->IsObject()) {
     scoped_ptr<blink::WebArrayBuffer> web_array_buffer(
-        blink::WebArrayBufferConverter::createFromV8Value(
-            val, context->GetIsolate()));
+        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) {
+      v8::Handle<v8::Object> object = val->ToObject();
+      *result = content::HostGlobals::Get()->
+          host_var_tracker()->V8ObjectVarForV8Object(instance, object);
     } else {
       bool was_resource;
       if (!resource_converter->FromV8Value(
               val->ToObject(), context, result, &was_resource))
         return false;
       if (!was_resource) {
         *result = (new DictionaryVar())->GetPPVar();
       }
     }
   } else {
@@ skipping 12 matching lines @@
   return true;
 }
 
 bool CanHaveChildren(PP_Var var) {
   return var.type == PP_VARTYPE_ARRAY || var.type == PP_VARTYPE_DICTIONARY;
 }
 
 }  // namespace
 
 V8VarConverter::V8VarConverter(PP_Instance instance)
-    : message_loop_proxy_(base::MessageLoopProxy::current()) {
+    : instance_(instance),
+      object_vars_allowed_(false),
+      message_loop_proxy_(base::MessageLoopProxy::current()) {
+  resource_converter_.reset(new ResourceConverterImpl(
+      instance, RendererPpapiHost::GetForPPInstance(instance)));
+}
+
+V8VarConverter::V8VarConverter(PP_Instance instance, bool object_vars_allowed)
+    : instance_(instance),
+      object_vars_allowed_(object_vars_allowed),
+      message_loop_proxy_(base::MessageLoopProxy::current()) {
   resource_converter_.reset(new ResourceConverterImpl(
       instance, RendererPpapiHost::GetForPPInstance(instance)));
 }
 
 V8VarConverter::V8VarConverter(PP_Instance instance,
                                scoped_ptr<ResourceConverter> resource_converter)
-    : message_loop_proxy_(base::MessageLoopProxy::current()),
+    : instance_(instance),
+      object_vars_allowed_(false),
+      message_loop_proxy_(base::MessageLoopProxy::current()),
       resource_converter_(resource_converter.release()) {}
 
 V8VarConverter::~V8VarConverter() {}
 
 // To/FromV8Value use a stack-based DFS search to traverse V8/Var graph. Each
 // 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.
@@ skipping 25 matching lines @@
       if (CanHaveChildren(current_var))
         parent_ids.erase(current_var.value.as_id);
       continue;
     } else {
       stack.top().sentinel = true;
     }
 
     bool did_create = false;
     if (!GetOrCreateV8Value(context,
                             current_var,
+                            object_vars_allowed_,
                             &current_v8,
                             &did_create,
                             &visited_ids,
                             &parent_ids,
                             resource_converter_.get())) {
       return false;
     }
 
     if (is_root) {
       is_root = false;
       root = current_v8;
     }
 
     // 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>();
 
       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;
         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;
@@ skipping 15 matching lines @@
 
       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;
         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;
@@ skipping 66 matching lines @@
       if (current_v8->IsObject())
         parent_handles.erase(HashedHandle(current_v8->ToObject()));
       continue;
     } else {
       stack.top().sentinel = true;
     }
 
     bool did_create = false;
     if (!GetOrCreateVar(current_v8,
                         context,
+                        instance_,
+                        object_vars_allowed_,
                         &current_var,
                         &did_create,
                         &visited_handles,
                         &parent_handles,
                         resource_converter_.get())) {
       return false;
     }
 
     if (is_root) {
       is_root = false;
@@ skipping 17 matching lines @@
         v8::Handle<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);
 
@@ skipping 29 matching lines @@
         v8::String::Utf8Value name_utf8(key->ToString());
 
         v8::TryCatch try_catch;
         v8::Handle<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