Plugin Power Saver: Add comprehensive browser tests.

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"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "content/renderer/pepper/host_array_buffer_var.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/pepper_try_catch.h"
+#include "content/renderer/pepper/plugin_instance_throttler_impl.h"
 #include "content/renderer/pepper/plugin_module.h"
 #include "content/renderer/pepper/plugin_object.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/function_template.h"
 #include "gin/object_template_builder.h"
 #include "gin/public/gin_embedders.h"
+#include "ppapi/shared_impl/ppapi_constants.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebDOMMessageEvent.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
 #include "v8/include/v8.h"
 
 using ppapi::ArrayBufferVar;
 using ppapi::PpapiGlobals;
 using ppapi::ScopedPPVar;
 using ppapi::StringVar;
 using blink::WebBindings;
 using blink::WebElement;
 using blink::WebDOMEvent;
 using blink::WebDOMMessageEvent;
 using blink::WebPluginContainer;
 using blink::WebSerializedScriptValue;
 
 namespace content {
 
 namespace {
 
+const char kIsPeripheral[] = "isPeripheral";
 const char kPostMessage[] = "postMessage";
 const char kPostMessageAndAwaitResponse[] = "postMessageAndAwaitResponse";
 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 "
     "argument from a PP_Var to a Javascript value. It may have cycles or be of "
     "an unsupported type.";
@@ skipping 156 matching lines @@
 
   PepperTryCatchV8 try_catch(instance_, &var_converter_, isolate);
   if (identifier == kPostMessage) {
     return GetFunctionTemplate(isolate, identifier,
                                &MessageChannel::PostMessageToNative)
         ->GetFunction();
   } else if (identifier == kPostMessageAndAwaitResponse) {
     return GetFunctionTemplate(isolate, identifier,
                                &MessageChannel::PostBlockingMessageToNative)
         ->GetFunction();
+  } else if (instance_->module()->name() == ppapi::kPpapiTestLibraryName &&
+             identifier == kIsPeripheral) {
+    return GetFunctionTemplate(isolate, identifier,
+                               &MessageChannel::IsPeripheralToNative)
+        ->GetFunction();
   }
 
   std::map<std::string, ScopedPPVar>::const_iterator it =
       internal_named_properties_.find(identifier);
   if (it != internal_named_properties_.end()) {
     v8::Handle<v8::Value> result = try_catch.ToV8(it->second.get());
     if (try_catch.ThrowException())
       return v8::Local<v8::Value>();
     return result;
   }
 
   PluginObject* plugin_object = GetPluginObject(isolate);
   if (plugin_object)
     return plugin_object->GetNamedProperty(isolate, identifier);
   return v8::Local<v8::Value>();
 }
 
 bool MessageChannel::SetNamedProperty(v8::Isolate* isolate,
                                       const std::string& identifier,
                                       v8::Local<v8::Value> value) {
   if (!instance_)
     return false;
   PepperTryCatchV8 try_catch(instance_, &var_converter_, isolate);
+  if (instance_->module()->name() == ppapi::kPpapiTestLibraryName &&
+      identifier == kIsPeripheral) {
+    try_catch.ThrowException("Cannot set property with the name isPeripheral");
+    return true;
+  }
   if (identifier == kPostMessage ||
       identifier == kPostMessageAndAwaitResponse) {
     try_catch.ThrowException("Cannot set properties with the name postMessage"
                              "or postMessageAndAwaitResponse");
     return true;
   }
 
   // TODO(raymes): This is only used by the gTalk plugin which is deprecated.
   // Remove passthrough of SetProperty calls as soon as it is removed.
   PluginObject* plugin_object = GetPluginObject(isolate);
   if (plugin_object)
     return plugin_object->SetNamedProperty(isolate, identifier, value);
 
   return false;
 }
 
 std::vector<std::string> MessageChannel::EnumerateNamedProperties(
     v8::Isolate* isolate) {
   std::vector<std::string> result;
   PluginObject* plugin_object = GetPluginObject(isolate);
   if (plugin_object)
     result = plugin_object->EnumerateNamedProperties(isolate);
+
+  if (instance_->module()->name() == ppapi::kPpapiTestLibraryName)
+    result.push_back(kIsPeripheral);
+
   result.push_back(kPostMessage);
   result.push_back(kPostMessageAndAwaitResponse);
   return result;
 }
 
 void MessageChannel::PostMessageToNative(gin::Arguments* args) {
   if (!instance_)
     return;
   if (args->Length() != 1) {
     // TODO(raymes): Consider throwing an exception here. We don't now for
@@ skipping 62 matching lines @@
         "and PPP_MessageHandler.");
     return;
   }
   v8::Handle<v8::Value> v8_result = try_catch.ToV8(pp_result.get());
   if (try_catch.ThrowException())
     return;
 
   args->Return(v8_result);
 }
 
+void MessageChannel::IsPeripheralToNative(gin::Arguments* args) {
+  if (!instance_)
+    return;
+  PepperTryCatchV8 try_catch(instance_, &var_converter_, args->isolate());
+  if (args->Length() != 0) {
+    try_catch.ThrowException("isPeripheral takes no arguments");
+    return;
+  }
+
+  bool is_peripheral =
+      instance_->throttler() && instance_->throttler()->power_saver_enabled();
+
+  v8::Handle<v8::Value> v8_result =
+      v8::Boolean::New(args->isolate(), is_peripheral);
+  args->Return(v8_result);
+}
+
 void MessageChannel::PostMessageToJavaScriptImpl(
     const WebSerializedScriptValue& message_data) {
   DCHECK(instance_);
 
   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;
 
@@ skipping 111 matching lines @@
   v8::Local<v8::FunctionTemplate> function_template = template_cache_.Get(name);
   if (!function_template.IsEmpty())
     return function_template;
   function_template = gin::CreateFunctionTemplate(
       isolate, base::Bind(memberFuncPtr, weak_ptr_factory_.GetWeakPtr()));
   template_cache_.Set(name, function_template);
   return function_template;
 }
 
 }  // namespace content