Use V8 Maybe APIs in extensions/renderer

extensions/renderer/messaging_bindings.cc

 // Copyright 2014 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 "extensions/renderer/messaging_bindings.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 10 matching lines @@
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/api/messaging/message.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/externally_connectable.h"
 #include "extensions/renderer/dispatcher.h"
 #include "extensions/renderer/event_bindings.h"
 #include "extensions/renderer/object_backed_native_handler.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_context_set.h"
+#include "extensions/renderer/v8_maybe_helpers.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebScopedWindowFocusAllowedIndicator.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "v8/include/v8.h"
 
 // Message passing API example (in a content script):
 // var extension =
@@ skipping 138 matching lines @@
 
   // Sends a message along the given channel.
   void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
     content::RenderFrame* renderframe = context()->GetRenderFrame();
     if (!renderframe)
       return;
 
     // Arguments are (int32 port_id, string message).
     CHECK(args.Length() == 2 && args[0]->IsInt32() && args[1]->IsString());
 
-    int port_id = args[0]->Int32Value();
+    int port_id = args[0].As<v8::Int32>()->Value();
     if (!HasPortData(port_id)) {
-      args.GetIsolate()->ThrowException(v8::Exception::Error(
-          v8::String::NewFromUtf8(args.GetIsolate(), kPortClosedError)));
+      v8::Local<v8::String> error_message =
+          ToV8String(args.GetIsolate(), kPortClosedError);
+      args.GetIsolate()->ThrowException(v8::Exception::Error(error_message));
       return;
     }
 
     renderframe->Send(new ExtensionHostMsg_PostMessage(
         renderframe->GetRoutingID(), port_id,
         Message(*v8::String::Utf8Value(args[1]),
                 blink::WebUserGestureIndicator::isProcessingUserGesture())));
   }
 
   // Forcefully disconnects a port.
   void CloseChannel(const v8::FunctionCallbackInfo<v8::Value>& args) {
     // Arguments are (int32 port_id, boolean notify_browser).
     CHECK_EQ(2, args.Length());
     CHECK(args[0]->IsInt32());
     CHECK(args[1]->IsBoolean());
 
-    int port_id = args[0]->Int32Value();
+    int port_id = args[0].As<v8::Int32>()->Value();
     if (!HasPortData(port_id))
       return;
 
     // Send via the RenderThread because the RenderFrame might be closing.
-    bool notify_browser = args[1]->BooleanValue();
+    bool notify_browser = args[1].As<v8::Boolean>()->Value();
     if (notify_browser) {
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_CloseChannel(port_id, std::string()));
     }
 
     ClearPortDataAndNotifyDispatcher(port_id);
   }
 
   // A new port has been created for a context.  This occurs both when script
   // opens a connection, and when a connection is opened to this script.
   void PortAddRef(const v8::FunctionCallbackInfo<v8::Value>& args) {
     // Arguments are (int32 port_id).
     CHECK_EQ(1, args.Length());
     CHECK(args[0]->IsInt32());
 
-    int port_id = args[0]->Int32Value();
+    int port_id = args[0].As<v8::Int32>()->Value();
     ++GetPortData(port_id).ref_count;
   }
 
   // The frame a port lived in has been destroyed.  When there are no more
   // frames with a reference to a given port, we will disconnect it and notify
   // the other end of the channel.
   void PortRelease(const v8::FunctionCallbackInfo<v8::Value>& args) {
     // Arguments are (int32 port_id).
     CHECK(args.Length() == 1 && args[0]->IsInt32());
-    ReleasePort(args[0]->Int32Value());
+    ReleasePort(args[0].As<v8::Int32>()->Value());
   }
 
   // Implementation of both the PortRelease native handler call, and callback
   // when contexts are invalidated to release their ports.
   void ReleasePort(int port_id) {
     if (HasPortData(port_id) && --GetPortData(port_id).ref_count == 0) {
       // Send via the RenderThread because the RenderFrame might be closing.
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_CloseChannel(port_id, std::string()));
       ClearPortDataAndNotifyDispatcher(port_id);
     }
   }
 
   // void BindToGC(object, callback, port_id)
   //
   // Binds |callback| to be invoked *sometime after* |object| is garbage
   // collected. We don't call the method re-entrantly so as to avoid executing
   // JS in some bizarro undefined mid-GC state, nor do we then call into the
   // script context if it's been invalidated.
   //
   // If the script context *is* invalidated in the meantime, as a slight hack,
   // release the port with ID |port_id| if it's >= 0.
   void BindToGC(const v8::FunctionCallbackInfo<v8::Value>& args) {
     CHECK(args.Length() == 3 && args[0]->IsObject() && args[1]->IsFunction() &&
           args[2]->IsInt32());
-    int port_id = args[2]->Int32Value();
+    int port_id = args[2].As<v8::Int32>()->Value();
     base::Closure fallback = base::Bind(&base::DoNothing);
     if (port_id >= 0) {
       fallback = base::Bind(&ExtensionImpl::ReleasePort,
                             weak_ptr_factory_.GetWeakPtr(), port_id);
     }
     // Destroys itself when the object is GC'd or context is invalidated.
     new GCCallback(context(), args[0].As<v8::Object>(),
                    args[1].As<v8::Function>(), fallback);
   }
 
@@ skipping 32 matching lines @@
   v8::Local<v8::Value> tls_channel_id_value = v8::Undefined(isolate);
   v8::Local<v8::Value> guest_process_id = v8::Undefined(isolate);
 
   if (extension) {
     if (!source->tab.empty() && !extension->is_platform_app())
       tab = converter->ToV8Value(&source->tab, script_context->v8_context());
 
     ExternallyConnectableInfo* externally_connectable =
         ExternallyConnectableInfo::Get(extension);
     if (externally_connectable &&
-        externally_connectable->accepts_tls_channel_id) {
-      tls_channel_id_value = v8::String::NewFromUtf8(isolate,
-                                                     tls_channel_id.c_str(),
-                                                     v8::String::kNormalString,
-                                                     tls_channel_id.size());
+        externally_connectable->accepts_tls_channel_id &&
+        tls_channel_id.size() < v8::String::kMaxLength) {
+      tls_channel_id_value =
+          ToV8String(isolate, tls_channel_id.c_str());
     }
 
     if (info.guest_process_id != content::ChildProcessHost::kInvalidUniqueID)
       guest_process_id = v8::Integer::New(isolate, info.guest_process_id);
   }
 
+  if (channel_name.size() >= v8::String::kMaxLength ||
+      info.source_id.size() >= v8::String::kMaxLength ||
+      target_extension_id.size() >= v8::String::kMaxLength ||
+      source_url_spec.size() >= v8::String::kMaxLength) {
+    LOG(ERROR) << "Failed to execute dispatchOnConnect.";
+    return;
+  }
+
   v8::Local<v8::Value> arguments[] = {
       // portId
       v8::Integer::New(isolate, target_port_id),
       // channelName
-      v8::String::NewFromUtf8(isolate, channel_name.c_str(),
-                              v8::String::kNormalString, channel_name.size()),
+      ToV8String(isolate, channel_name.c_str()),
       // sourceTab
       tab,
       // source_frame_id
       v8::Integer::New(isolate, source->frame_id),
       // guestProcessId
       guest_process_id,
       // sourceExtensionId
-      v8::String::NewFromUtf8(isolate, info.source_id.c_str(),
-                              v8::String::kNormalString, info.source_id.size()),
+      ToV8String(isolate, info.source_id.c_str()),
       // targetExtensionId
-      v8::String::NewFromUtf8(isolate, target_extension_id.c_str(),
-                              v8::String::kNormalString,
-                              target_extension_id.size()),
+      ToV8String(isolate, target_extension_id.c_str()),
       // sourceUrl
-      v8::String::NewFromUtf8(isolate, source_url_spec.c_str(),
-                              v8::String::kNormalString,
-                              source_url_spec.size()),
+      ToV8String(isolate, source_url_spec.c_str()),
       // tlsChannelId
       tls_channel_id_value,
   };
 
   v8::Local<v8::Value> retval =
       script_context->module_system()->CallModuleMethod(
           "messaging", "dispatchOnConnect", arraysize(arguments), arguments);
 
   if (!retval.IsEmpty()) {
     CHECK(retval->IsBoolean());
-    *port_created |= retval->BooleanValue();
+    *port_created |= retval.As<v8::Boolean>()->Value();
   } else {
     LOG(ERROR) << "Empty return value from dispatchOnConnect.";
   }
 }
 
 void DeliverMessageToScriptContext(const Message& message,
                                    int target_port_id,
                                    ScriptContext* script_context) {
   v8::Isolate* isolate = script_context->isolate();
   v8::HandleScope handle_scope(isolate);
 
   // Check to see whether the context has this port before bothering to create
   // the message.
   v8::Local<v8::Value> port_id_handle =
       v8::Integer::New(isolate, target_port_id);
   v8::Local<v8::Value> has_port =
       script_context->module_system()->CallModuleMethod("messaging", "hasPort",
                                                         1, &port_id_handle);
 
   CHECK(!has_port.IsEmpty());
-  if (!has_port->BooleanValue())
+  if (!has_port->IsBoolean() || !has_port.As<v8::Boolean>()->Value())
     return;
 
+  if (message.data.size() >= v8::String::kMaxLength)
+    return;
   std::vector<v8::Local<v8::Value>> arguments;
-  arguments.push_back(v8::String::NewFromUtf8(isolate,
-                                              message.data.c_str(),
-                                              v8::String::kNormalString,
-                                              message.data.size()));
+  arguments.push_back(ToV8String(isolate, message.data.c_str()));
   arguments.push_back(port_id_handle);
 
   scoped_ptr<blink::WebScopedUserGesture> web_user_gesture;
   scoped_ptr<blink::WebScopedWindowFocusAllowedIndicator> allow_window_focus;
   if (message.user_gesture) {
     web_user_gesture.reset(new blink::WebScopedUserGesture);
 
     if (script_context->web_frame()) {
       blink::WebDocument document = script_context->web_frame()->document();
       allow_window_focus.reset(new blink::WebScopedWindowFocusAllowedIndicator(
           &document));
     }
   }
 
   script_context->module_system()->CallModuleMethod(
       "messaging", "dispatchOnMessage", &arguments);
 }
 
 void DispatchOnDisconnectToScriptContext(int port_id,
                                          const std::string& error_message,
                                          ScriptContext* script_context) {
   v8::Isolate* isolate = script_context->isolate();
   v8::HandleScope handle_scope(isolate);
 
   std::vector<v8::Local<v8::Value>> arguments;
   arguments.push_back(v8::Integer::New(isolate, port_id));
   if (!error_message.empty()) {
     arguments.push_back(
-        v8::String::NewFromUtf8(isolate, error_message.c_str()));
+        ToV8String(isolate, error_message.c_str()));
   } else {
     arguments.push_back(v8::Null(isolate));
   }
 
   script_context->module_system()->CallModuleMethod(
       "messaging", "dispatchOnDisconnect", &arguments);
 }
 
 }  // namespace
 
@@ skipping 53 matching lines @@
   // TODO(robwu): ScriptContextSet.ForEach should accept RenderFrame*.
   content::RenderView* restrict_to_render_view =
       restrict_to_render_frame ? restrict_to_render_frame->GetRenderView()
                                : NULL;
   context_set.ForEach(
       restrict_to_render_view,
       base::Bind(&DispatchOnDisconnectToScriptContext, port_id, error_message));
 }
 
 }  // namespace extensions