PPAPI: Run clang_format.py on content/renderer/pepper

content/renderer/pepper/message_channel.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 "content/renderer/pepper/message_channel.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 using blink::WebDOMEvent;
 using blink::WebDOMMessageEvent;
 using blink::WebPluginContainer;
 using blink::WebSerializedScriptValue;
 
 namespace content {
 
 namespace {
 
 const char kPostMessage[] = "postMessage";
-const char kV8ToVarConversionError[] = "Failed to convert a PostMessage "
+const char kV8ToVarConversionError[] =
+    "Failed to convert a PostMessage "
     "argument from a JavaScript value to a PP_Var. It may have cycles or be of "
     "an unsupported type.";
-const char kVarToV8ConversionError[] = "Failed to convert a PostMessage "
+const char kVarToV8ConversionError[] =
+    "Failed to convert a PostMessage "
     "argument from a PP_Var to a Javascript value. It may have cycles or be of "
     "an unsupported type.";
 
 // Helper function to get the MessageChannel that is associated with an
 // NPObject*.
 MessageChannel* ToMessageChannel(NPObject* object) {
-  return static_cast<MessageChannel::MessageChannelNPObject*>(object)->
-      message_channel.get();
+  return static_cast<MessageChannel::MessageChannelNPObject*>(object)
+      ->message_channel.get();
 }
 
 NPObject* ToPassThroughObject(NPObject* object) {
   MessageChannel* channel = ToMessageChannel(object);
   return channel ? channel->passthrough_object() : NULL;
 }
 
 // Helper function to determine if a given identifier is equal to kPostMessage.
 bool IdentifierIsPostMessage(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kPostMessage) == identifier;
@@ skipping 13 matching lines @@
     case PP_VARTYPE_STRING: {
       StringVar* string = StringVar::FromPPVar(var);
       if (!string)
         return PP_MakeUndefined();
       return StringVar::StringToPPVar(string->value());
     }
     case 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());
+      PP_Var new_buffer_var =
+          PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
+              buffer->ByteLength());
       DCHECK(new_buffer_var.type == PP_VARTYPE_ARRAY_BUFFER);
       if (new_buffer_var.type != PP_VARTYPE_ARRAY_BUFFER)
         return PP_MakeUndefined();
       ArrayBufferVar* new_buffer = ArrayBufferVar::FromPPVar(new_buffer_var);
       DCHECK(new_buffer);
       if (!new_buffer)
         return PP_MakeUndefined();
       memcpy(new_buffer->Map(), buffer->Map(), buffer->ByteLength());
       return new_buffer_var;
     }
@@ skipping 34 matching lines @@
   if (IdentifierIsPostMessage(name))
     return true;
 
   // Other method names we will pass to the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough)
     return WebBindings::hasMethod(NULL, passthrough, name);
   return false;
 }
 
-bool MessageChannelInvoke(NPObject* np_obj, NPIdentifier name,
-                          const NPVariant* args, uint32 arg_count,
+bool MessageChannelInvoke(NPObject* np_obj,
+                          NPIdentifier name,
+                          const NPVariant* args,
+                          uint32 arg_count,
                           NPVariant* result) {
   if (!np_obj)
     return false;
 
   // We only handle a function called postMessage.
   if (IdentifierIsPostMessage(name) && (arg_count == 1)) {
     MessageChannel* message_channel = ToMessageChannel(np_obj);
     if (message_channel) {
       message_channel->NPVariantToPPVar(&args[0]);
       return true;
     } else {
       return false;
     }
   }
   // Other method calls we will pass to the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough) {
-    return WebBindings::invoke(NULL, passthrough, name, args, arg_count,
-                               result);
+    return WebBindings::invoke(
+        NULL, passthrough, name, args, arg_count, result);
   }
   return false;
 }
 
 bool MessageChannelInvokeDefault(NPObject* np_obj,
                                  const NPVariant* args,
                                  uint32 arg_count,
                                  NPVariant* result) {
   if (!np_obj)
     return false;
 
   // Invoke on the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough) {
-    return WebBindings::invokeDefault(NULL, passthrough, args, arg_count,
-                                      result);
+    return WebBindings::invokeDefault(
+        NULL, passthrough, args, arg_count, result);
   }
   return false;
 }
 
 bool MessageChannelHasProperty(NPObject* np_obj, NPIdentifier name) {
   if (!np_obj)
     return false;
 
   MessageChannel* message_channel = ToMessageChannel(np_obj);
   if (message_channel) {
     if (message_channel->GetReadOnlyProperty(name, NULL))
       return true;
   }
 
   // Invoke on the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough)
     return WebBindings::hasProperty(NULL, passthrough, name);
   return false;
 }
 
-bool MessageChannelGetProperty(NPObject* np_obj, NPIdentifier name,
+bool MessageChannelGetProperty(NPObject* np_obj,
+                               NPIdentifier name,
                                NPVariant* result) {
   if (!np_obj)
     return false;
 
   // Don't allow getting the postMessage function.
   if (IdentifierIsPostMessage(name))
     return false;
 
   MessageChannel* message_channel = ToMessageChannel(np_obj);
   if (message_channel) {
     if (message_channel->GetReadOnlyProperty(name, result))
       return true;
   }
 
   // Invoke on the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough)
     return WebBindings::getProperty(NULL, passthrough, name, result);
   return false;
 }
 
-bool MessageChannelSetProperty(NPObject* np_obj, NPIdentifier name,
+bool MessageChannelSetProperty(NPObject* np_obj,
+                               NPIdentifier name,
                                const NPVariant* variant) {
   if (!np_obj)
     return false;
 
   // Don't allow setting the postMessage function.
   if (IdentifierIsPostMessage(name))
     return false;
 
   // Invoke on the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough)
     return WebBindings::setProperty(NULL, passthrough, name, variant);
   return false;
 }
 
-bool MessageChannelEnumerate(NPObject *np_obj, NPIdentifier **value,
-                             uint32_t *count) {
+bool MessageChannelEnumerate(NPObject* np_obj,
+                             NPIdentifier** value,
+                             uint32_t* count) {
   if (!np_obj)
     return false;
 
   // Invoke on the passthrough object, if we have one, to enumerate its
   // properties.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough) {
     bool success = WebBindings::enumerate(NULL, passthrough, value, count);
     if (success) {
       // Add postMessage to the list and return it.
       if (std::numeric_limits<size_t>::max() / sizeof(NPIdentifier) <=
           static_cast<size_t>(*count) + 1)  // Else, "always false" x64 warning.
         return false;
       NPIdentifier* new_array = static_cast<NPIdentifier*>(
           std::malloc(sizeof(NPIdentifier) * (*count + 1)));
-      std::memcpy(new_array, *value, sizeof(NPIdentifier)*(*count));
+      std::memcpy(new_array, *value, sizeof(NPIdentifier) * (*count));
       new_array[*count] = WebBindings::getStringIdentifier(kPostMessage);
       std::free(*value);
       *value = new_array;
       ++(*count);
       return true;
     }
   }
 
   // Otherwise, build an array that includes only postMessage.
   *value = static_cast<NPIdentifier*>(malloc(sizeof(NPIdentifier)));
   (*value)[0] = WebBindings::getStringIdentifier(kPostMessage);
   *count = 1;
   return true;
 }
 
 NPClass message_channel_class = {
-  NP_CLASS_STRUCT_VERSION,
-  &MessageChannelAllocate,
-  &MessageChannelDeallocate,
-  NULL,
-  &MessageChannelHasMethod,
-  &MessageChannelInvoke,
-  &MessageChannelInvokeDefault,
-  &MessageChannelHasProperty,
-  &MessageChannelGetProperty,
-  &MessageChannelSetProperty,
-  NULL,
-  &MessageChannelEnumerate,
-};
+    NP_CLASS_STRUCT_VERSION,      &MessageChannelAllocate,
+    &MessageChannelDeallocate,    NULL,
+    &MessageChannelHasMethod,     &MessageChannelInvoke,
+    &MessageChannelInvokeDefault, &MessageChannelHasProperty,
+    &MessageChannelGetProperty,   &MessageChannelSetProperty,
+    NULL,                         &MessageChannelEnumerate, };
 
 }  // namespace
 
 // MessageChannel --------------------------------------------------------------
 struct MessageChannel::VarConversionResult {
   VarConversionResult(const ppapi::ScopedPPVar& r, bool s)
-      : result(r),
-        success(s),
-        conversion_completed(true) {}
-  VarConversionResult()
-      : success(false),
-        conversion_completed(false) {}
+      : result(r), success(s), conversion_completed(true) {}
+  VarConversionResult() : success(false), conversion_completed(false) {}
   ppapi::ScopedPPVar result;
   bool success;
   bool conversion_completed;
 };
 
-MessageChannel::MessageChannelNPObject::MessageChannelNPObject() {
-}
+MessageChannel::MessageChannelNPObject::MessageChannelNPObject() {}
 
 MessageChannel::MessageChannelNPObject::~MessageChannelNPObject() {}
 
 MessageChannel::MessageChannel(PepperPluginInstanceImpl* instance)
     : instance_(instance),
       passthrough_object_(NULL),
       np_object_(NULL),
       early_message_queue_state_(QUEUE_MESSAGES),
       weak_ptr_factory_(this) {
   // Now create an NPObject for receiving calls to postMessage. This sets the
   // reference count to 1.  We release it in the destructor.
   NPObject* obj = WebBindings::createObject(instance_->instanceNPP(),
                                             &message_channel_class);
   DCHECK(obj);
   np_object_ = static_cast<MessageChannel::MessageChannelNPObject*>(obj);
   np_object_->message_channel = weak_ptr_factory_.GetWeakPtr();
 }
 
 void MessageChannel::NPVariantToPPVar(const NPVariant* variant) {
   converted_var_queue_.push_back(VarConversionResult());
   std::list<VarConversionResult>::iterator result_iterator =
       --converted_var_queue_.end();
   switch (variant->type) {
     case NPVariantType_Void:
-      NPVariantToPPVarComplete(result_iterator,
-          ppapi::ScopedPPVar(PP_MakeUndefined()), true);
+      NPVariantToPPVarComplete(
+          result_iterator, ppapi::ScopedPPVar(PP_MakeUndefined()), true);
       return;
     case NPVariantType_Null:
-      NPVariantToPPVarComplete(result_iterator,
-          ppapi::ScopedPPVar(PP_MakeNull()), true);
+      NPVariantToPPVarComplete(
+          result_iterator, ppapi::ScopedPPVar(PP_MakeNull()), true);
       return;
     case NPVariantType_Bool:
       NPVariantToPPVarComplete(result_iterator,
-          ppapi::ScopedPPVar(
-              PP_MakeBool(PP_FromBool(NPVARIANT_TO_BOOLEAN(*variant)))),
-          true);
+                               ppapi::ScopedPPVar(PP_MakeBool(PP_FromBool(
+                                   NPVARIANT_TO_BOOLEAN(*variant)))),
+                               true);
       return;
     case NPVariantType_Int32:
-      NPVariantToPPVarComplete(result_iterator,
-          ppapi::ScopedPPVar(
-              PP_MakeInt32(NPVARIANT_TO_INT32(*variant))),
+      NPVariantToPPVarComplete(
+          result_iterator,
+          ppapi::ScopedPPVar(PP_MakeInt32(NPVARIANT_TO_INT32(*variant))),
           true);
       return;
     case NPVariantType_Double:
-      NPVariantToPPVarComplete(result_iterator,
-          ppapi::ScopedPPVar(
-              PP_MakeDouble(NPVARIANT_TO_DOUBLE(*variant))),
+      NPVariantToPPVarComplete(
+          result_iterator,
+          ppapi::ScopedPPVar(PP_MakeDouble(NPVARIANT_TO_DOUBLE(*variant))),
           true);
       return;
     case NPVariantType_String:
-      NPVariantToPPVarComplete(result_iterator,
+      NPVariantToPPVarComplete(
+          result_iterator,
           ppapi::ScopedPPVar(ppapi::ScopedPPVar::PassRef(),
                              StringVar::StringToPPVar(
                                  NPVARIANT_TO_STRING(*variant).UTF8Characters,
                                  NPVARIANT_TO_STRING(*variant).UTF8Length)),
           true);
       return;
     case NPVariantType_Object: {
       // Calling WebBindings::toV8Value creates a wrapper around NPVariant so it
       // shouldn't result in a deep copy.
       v8::Handle<v8::Value> v8_value = WebBindings::toV8Value(variant);
-      V8VarConverter(instance_->pp_instance()).FromV8Value(
-          v8_value, v8::Isolate::GetCurrent()->GetCurrentContext(),
-          base::Bind(&MessageChannel::NPVariantToPPVarComplete,
-                     weak_ptr_factory_.GetWeakPtr(), result_iterator));
+      V8VarConverter(instance_->pp_instance())
+          .FromV8Value(v8_value,
+                       v8::Isolate::GetCurrent()->GetCurrentContext(),
+                       base::Bind(&MessageChannel::NPVariantToPPVarComplete,
+                                  weak_ptr_factory_.GetWeakPtr(),
+                                  result_iterator));
       return;
     }
   }
-  NPVariantToPPVarComplete(result_iterator,
-      ppapi::ScopedPPVar(PP_MakeUndefined()), false);
+  NPVariantToPPVarComplete(
+      result_iterator, ppapi::ScopedPPVar(PP_MakeUndefined()), false);
 }
 
 void MessageChannel::PostMessageToJavaScript(PP_Var message_data) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
 
   // Because V8 is probably not on the stack for Native->JS calls, we need to
   // enter the appropriate context for the plugin.
   WebPluginContainer* container = instance_->container();
   // It's possible that container() is NULL if the plugin has been removed from
   // the DOM (but the PluginInstance is not destroyed yet).
   if (!container)
     return;
 
   v8::Local<v8::Context> context =
       container->element().document().frame()->mainWorldScriptContext();
   // If the page is being destroyed, the context may be empty.
   if (context.IsEmpty())
     return;
   v8::Context::Scope context_scope(context);
 
   v8::Handle<v8::Value> v8_val;
-  if (!V8VarConverter(instance_->pp_instance()).ToV8Value(
-          message_data, context, &v8_val)) {
+  if (!V8VarConverter(instance_->pp_instance())
+           .ToV8Value(message_data, context, &v8_val)) {
     PpapiGlobals::Get()->LogWithSource(instance_->pp_instance(),
-        PP_LOGLEVEL_ERROR, std::string(), kVarToV8ConversionError);
+                                       PP_LOGLEVEL_ERROR,
+                                       std::string(),
+                                       kVarToV8ConversionError);
     return;
   }
 
   WebSerializedScriptValue serialized_val =
       WebSerializedScriptValue::serialize(v8_val);
 
   if (instance_->module()->IsProxied()) {
     if (early_message_queue_state_ != SEND_DIRECTLY) {
       // We can't just PostTask here; the messages would arrive out of
       // order. Instead, we queue them up until we're ready to post
@@ skipping 36 matching lines @@
     const std::list<VarConversionResult>::iterator& result_iterator,
     const ppapi::ScopedPPVar& result,
     bool success) {
   *result_iterator = VarConversionResult(result, success);
   std::list<VarConversionResult>::iterator it = converted_var_queue_.begin();
   while (it != converted_var_queue_.end() && it->conversion_completed) {
     if (it->success) {
       PostMessageToNative(it->result.get());
     } else {
       PpapiGlobals::Get()->LogWithSource(instance()->pp_instance(),
-          PP_LOGLEVEL_ERROR, std::string(), kV8ToVarConversionError);
+                                         PP_LOGLEVEL_ERROR,
+                                         std::string(),
+                                         kV8ToVarConversionError);
     }
 
     converted_var_queue_.erase(it++);
   }
 }
 
 void MessageChannel::DrainEarlyMessageQueue() {
   // Take a reference on the PluginInstance. This is because JavaScript code
   // may delete the plugin, which would destroy the PluginInstance and its
   // corresponding MessageChannel.
@@ skipping 18 matching lines @@
 
   WebPluginContainer* container = instance_->container();
   // It's possible that container() is NULL if the plugin has been removed from
   // the DOM (but the PluginInstance is not destroyed yet).
   if (!container)
     return;
 
   WebDOMEvent event =
       container->element().document().createEvent("MessageEvent");
   WebDOMMessageEvent msg_event = event.to<WebDOMMessageEvent>();
-  msg_event.initMessageEvent("message",  // type
-                             false,  // canBubble
-                             false,  // cancelable
+  msg_event.initMessageEvent("message",     // type
+                             false,         // canBubble
+                             false,         // cancelable
                              message_data,  // data
-                             "",  // origin [*]
-                             NULL,  // source [*]
-                             "");  // lastEventId
+                             "",            // origin [*]
+                             NULL,          // source [*]
+                             "");           // lastEventId
   // [*] Note that the |origin| is only specified for cross-document and server-
   //     sent messages, while |source| is only specified for cross-document
   //     messages:
   //      http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html
   //     This currently behaves like Web Workers. On Firefox, Chrome, and Safari
   //     at least, postMessage on Workers does not provide the origin or source.
   //     TODO(dmichael):  Add origin if we change to a more iframe-like origin
   //                      policy (see crbug.com/81537)
 
   container->element().dispatchEvent(msg_event);
@@ skipping 37 matching lines @@
   // incoming passthrough object first, so that we behave correctly if anyone
   // invokes:
   //   SetPassthroughObject(passthrough_object());
   if (passthrough_object_)
     WebBindings::releaseObject(passthrough_object_);
 
   passthrough_object_ = passthrough;
 }
 
 bool MessageChannel::GetReadOnlyProperty(NPIdentifier key,
-                                         NPVariant *value) const {
+                                         NPVariant* value) const {
   std::map<NPIdentifier, ppapi::ScopedPPVar>::const_iterator it =
       internal_properties_.find(key);
   if (it != internal_properties_.end()) {
     if (value)
       return PPVarToNPVariant(it->second.get(), value);
     return true;
   }
   return false;
 }
 
 void MessageChannel::SetReadOnlyProperty(PP_Var key, PP_Var value) {
   internal_properties_[PPVarToNPIdentifier(key)] = ppapi::ScopedPPVar(value);
 }
 
 }  // namespace content