Browser Plugin: Implement Back, Forward, and Go.

content/renderer/browser_plugin/browser_plugin_bindings.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/browser_plugin/browser_plugin_bindings.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
-#include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string16.h"
 #include "base/string_split.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/browser_plugin/browser_plugin.h"
 #include "third_party/npapi/bindings/npapi.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"
@@ skipping 10 matching lines @@
 using WebKit::WebDOMMessageEvent;
 using WebKit::WebPluginContainer;
 using WebKit::WebSerializedScriptValue;
 using WebKit::WebString;
 
 namespace content {
 
 namespace {
 
 const char kAddEventListener[] = "addEventListener";
+const char kBackMethod[] = "back";
+const char kForwardMethod[] = "forward";
 const char kGetProcessId[] = "getProcessId";
+const char kGoMethod[] = "go";
 const char kPartitionAttribute[] = "partition";
 const char kReloadMethod[] = "reload";
 const char kRemoveEventListener[] = "removeEventListener";
 const char kSrcAttribute[] = "src";
 const char kStopMethod[] = "stop";
 
 BrowserPluginBindings* GetBindings(NPObject* object) {
   return static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(object)->
       message_channel;
 }
 
 bool IdentifierIsReload(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kReloadMethod) == identifier;
 }
 
 bool IdentifierIsStop(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kStopMethod) == identifier;
 }
 
 bool IdentifierIsAddEventListener(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kAddEventListener) == identifier;
 }
 
+bool IdentifierIsBackMethod(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kBackMethod) == identifier;
+}
+
+bool IdentifierIsForwardMethod(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kForwardMethod) == identifier;
+}
+
+bool IdentifierIsGoMethod(NPIdentifier identifier) {
+  return WebBindings::getStringIdentifier(kGoMethod) == identifier;
+}
+
 bool IdentifierIsRemoveEventListener(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kRemoveEventListener) == identifier;
 }
 
 bool IdentifierIsGetProcessID(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kGetProcessId) == identifier;
 }
 
 bool IdentifierIsSrcAttribute(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kSrcAttribute) == identifier;
 }
 
 bool IdentifierIsPartitionAttribute(NPIdentifier identifier) {
   return WebBindings::getStringIdentifier(kPartitionAttribute) == identifier;
 }
 
+int Int32FromNPVariant(const NPVariant& variant) {
+  if (NPVARIANT_IS_INT32(variant))
+    return NPVARIANT_TO_INT32(variant);
+
+  if (NPVARIANT_IS_DOUBLE(variant))
+    return NPVARIANT_TO_DOUBLE(variant);
+
+  return 0;
+}
+
 std::string StringFromNPVariant(const NPVariant& variant) {
   if (!NPVARIANT_IS_STRING(variant))
     return std::string();
   const NPString& np_string = NPVARIANT_TO_STRING(variant);
   return std::string(np_string.UTF8Characters, np_string.UTF8Length);
 }
 
 string16 String16FromNPVariant(const NPVariant& variant) {
   if (!NPVARIANT_IS_STRING(variant))
     return string16();
@@ skipping 30 matching lines @@
   delete instance;
 }
 
 bool BrowserPluginBindingsHasMethod(NPObject* np_obj, NPIdentifier name) {
   if (!np_obj)
     return false;
 
   if (IdentifierIsAddEventListener(name))
     return true;
 
+  if (IdentifierIsBackMethod(name))
+    return true;
+
+  if (IdentifierIsForwardMethod(name))
+    return true;
+
   if (IdentifierIsGetProcessID(name))
     return true;
 
+  if (IdentifierIsGoMethod(name))
+    return true;
+
   if (IdentifierIsReload(name))
     return true;
 
   if (IdentifierIsRemoveEventListener(name))
     return true;
 
   if (IdentifierIsStop(name))
     return true;
 
   return false;
@@ skipping 16 matching lines @@
 
     v8::Local<v8::Value> value =
         v8::Local<v8::Value>::New(WebBindings::toV8Value(&args[1]));
     if (value.IsEmpty() || !value->IsFunction())
       return false;
 
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(value);
     return bindings->instance()->AddEventListener(event_name, function);
   }
 
+  if (IdentifierIsBackMethod(name) && !arg_count) {
+    bindings->instance()->Back();
+    return true;
+  }
+
+  if (IdentifierIsForwardMethod(name) && !arg_count) {
+    bindings->instance()->Forward();
+    return true;
+  }
+
   if (IdentifierIsGetProcessID(name) && !arg_count) {
     int process_id = bindings->instance()->process_id();
     result->type = NPVariantType_Int32;
     result->value.intValue = process_id;
     return true;
   }
 
+  if (IdentifierIsGoMethod(name) && arg_count == 1) {
+    bindings->instance()->Go(Int32FromNPVariant(args[0]));
+    return true;
+  }
+
   if (IdentifierIsReload(name) && !arg_count) {
     bindings->instance()->Reload();
     return true;
   }
 
   if (IdentifierIsRemoveEventListener(name) && arg_count == 2) {
     std::string event_name = StringFromNPVariant(args[0]);
     if (event_name.empty())
       return false;
 
@@ skipping 29 matching lines @@
 }
 
 bool BrowserPluginBindingsGetProperty(NPObject* np_obj, NPIdentifier name,
                                       NPVariant* result) {
   if (!np_obj)
     return false;
 
   if (!result)
     return false;
 
-  if (IdentifierIsAddEventListener(name) ||
-      IdentifierIsRemoveEventListener(name))
-    return false;
-
   // All attributes from here on rely on the bindings, so retrieve it once and
   // return on failure.
   BrowserPluginBindings* bindings = GetBindings(np_obj);
   if (!bindings)
     return false;
 
   if (IdentifierIsSrcAttribute(name)) {
     std::string src = bindings->instance()->GetSrcAttribute();
     return StringToNPVariant(src, result);
   }
@@ skipping 79 matching lines @@
       WebBindings::createObject(NULL, &browser_plugin_message_class);
   np_object_ = static_cast<BrowserPluginBindings::BrowserPluginNPObject*>(obj);
   np_object_->message_channel = weak_ptr_factory_.GetWeakPtr();
 }
 
 BrowserPluginBindings::~BrowserPluginBindings() {
   WebBindings::releaseObject(np_object_);
 }
 
 }  // namespace content