Implement in-process PPB_VarArrayBuffer_Dev.

webkit/plugins/ppapi/message_channel.cc

 // Copyright (c) 2011 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 "webkit/plugins/ppapi/message_channel.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/var.h"
+#include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDOMMessageEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSerializedScriptValue.h"
 #include "v8/include/v8.h"
+#include "webkit/plugins/ppapi/host_array_buffer_var.h"
 #include "webkit/plugins/ppapi/npapi_glue.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
+using ppapi::ArrayBufferVar;
+using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using WebKit::WebBindings;
 using WebKit::WebElement;
 using WebKit::WebDOMEvent;
 using WebKit::WebDOMMessageEvent;
 using WebKit::WebPluginContainer;
 using WebKit::WebSerializedScriptValue;
 
 namespace webkit {
 
@@ skipping 41 matching lines @@
         result->Clear();
         return false;
       }
       const std::string& value = string->value();
       // TODO(dmichael): We should consider caching the V8 string in the host-
       // side StringVar, so that we only have to convert/copy once if a
       // string is sent more than once.
       *result = v8::String::New(value.c_str(), value.size());
       break;
     }
+    case PP_VARTYPE_ARRAY_BUFFER: {
+      ArrayBufferVar* buffer = ArrayBufferVar::FromPPVar(var);
+      if (!buffer) {
+        result->Clear();
+        return false;
+      }
+      HostArrayBufferVar* host_buffer =
+          static_cast<HostArrayBufferVar*>(buffer);
+      *result =
+          v8::Local<v8::Value>::New(host_buffer->webkit_buffer().toV8Value());
+      break;
+    }
     case PP_VARTYPE_OBJECT:
     case PP_VARTYPE_ARRAY:
     case PP_VARTYPE_DICTIONARY:
-    case PP_VARTYPE_ARRAY_BUFFER:
       // These are not currently supported.
       NOTIMPLEMENTED();
       result->Clear();
       return false;
   }
   return true;
 }
 
 // Copy a PP_Var in to a PP_Var that is appropriate for sending via postMessage.
 // This currently just copies the value.  For a string Var, the result is a
 // PP_Var with the a copy of |var|'s string contents and a reference count of 1.
 //
-// TODO(dmichael):  We need to do structured clone eventually to copy a object
-// structure.  The details and PPAPI changes for this are TBD.
+// TODO(dmichael): Bypass this step for out-of-process plugins, since a copy
+// happens already when the Var is serialized.
 PP_Var CopyPPVar(const PP_Var& var) {
   if (var.type == PP_VARTYPE_OBJECT) {
     // Objects are not currently supported.
     NOTIMPLEMENTED();
     return PP_MakeUndefined();
   } else if (var.type == PP_VARTYPE_STRING) {
     StringVar* string = StringVar::FromPPVar(var);
     if (!string)
       return PP_MakeUndefined();
     return StringVar::StringToPPVar(string->value());
+  } else if (var.type == PP_VARTYPE_ARRAY_BUFFER) {
+    ArrayBufferVar* buffer = ArrayBufferVar::FromPPVar(var);
+    if (!buffer)
+      return PP_MakeUndefined();
+    PP_Var new_buffer_var = PpapiGlobals::Get()->GetVarTracker()->
+        MakeArrayBufferPPVar(buffer->ByteLength());
+    ArrayBufferVar* new_buffer = ArrayBufferVar::FromPPVar(new_buffer_var);
+    memcpy(new_buffer->Map(), buffer->Map(), buffer->ByteLength());
+    return new_buffer_var;
   } else {
     return var;
   }
 }
 
 //------------------------------------------------------------------------------
 // Implementations of NPClass functions.  These are here to:
 // - Implement postMessage behavior.
 // - Forward calls to the 'passthrough' object to allow backwards-compatibility
 //   with GetInstanceObject() objects.
@@ skipping 170 matching lines @@
   // reference count to 1.  We release it in the destructor.
   NPObject* obj = WebBindings::createObject(NULL, &message_channel_class);
   DCHECK(obj);
   np_object_ = static_cast<MessageChannel::MessageChannelNPObject*>(obj);
   np_object_->message_channel = this;
 }
 
 void MessageChannel::PostMessageToJavaScript(PP_Var message_data) {
   // Serialize the message data.
   v8::HandleScope scope;
-  v8::Handle<v8::Value> v8_val;
+  // Because V8 is probably not on the stack for Native->JS calls, we need to
+  // enter the appropriate context for the plugin.
+  v8::Local<v8::Context> context =
+      instance_->container()->element().document().frame()->
+          mainWorldScriptContext();
+  context->Enter();
+  v8::Local<v8::Value> v8_val;
   if (!PPVarToV8Value(message_data, &v8_val)) {
     NOTREACHED();
     return;
   }
 
   WebSerializedScriptValue serialized_val =
       WebSerializedScriptValue::serialize(v8_val);
+  context->Exit();
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MessageChannel::PostMessageToJavaScriptImpl,
                  weak_ptr_factory_.GetWeakPtr(),
                  serialized_val));
 }
 
 void MessageChannel::PostMessageToJavaScriptImpl(
     const WebSerializedScriptValue& message_data) {
@@ skipping 58 matching lines @@
   //   SetPassthroughObject(passthrough_object());
   if (passthrough_object_)
     WebBindings::releaseObject(passthrough_object_);
 
   passthrough_object_ = passthrough;
 }
 
 }  // namespace ppapi
 }  // namespace webkit