Rename Instance_Trusted to Instance_Private, wire it up in Chrome.

webkit/plugins/ppapi/ppapi_plugin_instance.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/ppapi_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppb_messaging.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
+#include "ppapi/c/private/ppb_instance_private.h"
+#include "ppapi/c/private/ppp_instance_private.h"
 #include "printing/units.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.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/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRect.h"
@@ skipping 168 matching lines @@
 }
 
 const PPB_Instance ppb_instance = {
   &GetWindowObject,
   &GetOwnerElementObject,
   &BindGraphics,
   &IsFullFrame,
   &ExecuteScript,
 };
 
+const PPB_Instance_Private ppb_instance_private = {
+  &GetWindowObject,
+  &GetOwnerElementObject,
+  &ExecuteScript
+};
+
 void NumberOfFindResultsChanged(PP_Instance instance_id,
                                 int32_t total,
                                 PP_Bool final_result) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return;
 
   DCHECK_NE(instance->find_identifier(), -1);
   instance->delegate()->NumberOfFindResultsChanged(
       instance->find_identifier(), total, PPBoolToBool(final_result));
@@ skipping 172 matching lines @@
 const PPB_Fullscreen_Dev* PluginInstance::GetFullscreenInterface() {
   return &ppb_fullscreen;
 }
 
 // static
 const PPB_Messaging* PluginInstance::GetMessagingInterface() {
   return &ppb_messaging;
 }
 
 // static
+const PPB_Instance_Private* PluginInstance::GetPrivateInterface() {
+  return &ppb_instance_private;
+}
+
+// static
 const PPB_Zoom_Dev* PluginInstance::GetZoomInterface() {
   return &ppb_zoom;
 }
 
 // NOTE: Any of these methods that calls into the plugin needs to take into
 // account that the plugin may use Var to remove the <embed> from the DOM, which
 // will make the WebPluginImpl drop its reference, usually the last one. If a
 // method needs to access a member of the instance after the call has returned,
 // then it needs to keep its own reference on the stack.
 
@@ skipping 314 matching lines @@
 
 void PluginInstance::HandleMessage(PP_Var message) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadMessagingInterface())
     return;
   plugin_messaging_interface_->HandleMessage(pp_instance(), message);
 }
 
 PP_Var PluginInstance::GetInstanceObject() {
+  // Try the private interface first.  If it is not supported, we fall back to
+  // the primary PPP_Instance interface.
+  // TODO(dmichael): Remove support for PPP_Instance.GetInstanceObject
+  if (LoadPrivateInterface()) {
+    return plugin_private_interface_->GetInstanceObject(pp_instance());
+  }
   return instance_interface_->GetInstanceObject(pp_instance());
 }
 
 void PluginInstance::ViewChanged(const gfx::Rect& position,
                                  const gfx::Rect& clip) {
   fullscreen_ = (fullscreen_container_ != NULL);
   position_ = position;
 
   if (clip.IsEmpty()) {
     // WebKit can give weird (x,y) positions for empty clip rects (since the
@@ skipping 148 matching lines @@
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadFindInterface())
     return;
   find_identifier_ = -1;
   plugin_find_interface_->StopFind(pp_instance());
 }
 
 bool PluginInstance::LoadFindInterface() {
   if (!plugin_find_interface_) {
     plugin_find_interface_ =
-        reinterpret_cast<const PPP_Find_Dev*>(module_->GetPluginInterface(
+        static_cast<const PPP_Find_Dev*>(module_->GetPluginInterface(
             PPP_FIND_DEV_INTERFACE));
   }
 
   return !!plugin_find_interface_;
 }
 
 bool PluginInstance::LoadMessagingInterface() {
   if (!checked_for_plugin_messaging_interface_) {
     checked_for_plugin_messaging_interface_ = true;
     plugin_messaging_interface_ =
-        reinterpret_cast<const PPP_Messaging*>(module_->GetPluginInterface(
+        static_cast<const PPP_Messaging*>(module_->GetPluginInterface(
             PPP_MESSAGING_INTERFACE));
   }
 
   return !!plugin_messaging_interface_;
 }
 
 bool PluginInstance::LoadPdfInterface() {
   if (!plugin_pdf_interface_) {
     plugin_pdf_interface_ =
-        reinterpret_cast<const PPP_Pdf*>(module_->GetPluginInterface(
+        static_cast<const PPP_Pdf*>(module_->GetPluginInterface(
             PPP_PDF_INTERFACE));
   }
 
   return !!plugin_pdf_interface_;
 }
 
 bool PluginInstance::LoadSelectionInterface() {
   if (!plugin_selection_interface_) {
     plugin_selection_interface_ =
-        reinterpret_cast<const PPP_Selection_Dev*>(module_->GetPluginInterface(
+        static_cast<const PPP_Selection_Dev*>(module_->GetPluginInterface(
             PPP_SELECTION_DEV_INTERFACE));
   }
 
   return !!plugin_selection_interface_;
 }
 
+bool PluginInstance::LoadPrivateInterface() {
+  if (!plugin_private_interface_) {
+    plugin_private_interface_ = static_cast<const PPP_Instance_Private*>(
+            module_->GetPluginInterface(PPP_INSTANCE_PRIVATE_INTERFACE));
+  }
+
+  return !!plugin_private_interface_;
+}
+
 bool PluginInstance::LoadZoomInterface() {
   if (!plugin_zoom_interface_) {
     plugin_zoom_interface_ =
-        reinterpret_cast<const PPP_Zoom_Dev*>(module_->GetPluginInterface(
+        static_cast<const PPP_Zoom_Dev*>(module_->GetPluginInterface(
             PPP_ZOOM_DEV_INTERFACE));
   }
 
   return !!plugin_zoom_interface_;
 }
 
 bool PluginInstance::PluginHasFocus() const {
   return has_webkit_focus_ && has_content_area_focus_;
 }
 
 void PluginInstance::ReportGeometry() {
   // If this call was delayed, we may have transitioned back to fullscreen in
   // the mean time, so only report the geometry if we are actually in normal
   // mode.
   if (container_ && !fullscreen_container_)
     container_->reportGeometry();
 }
 
 bool PluginInstance::GetPreferredPrintOutputFormat(
     PP_PrintOutputFormat_Dev* format) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!plugin_print_interface_) {
     plugin_print_interface_ =
-        reinterpret_cast<const PPP_Printing_Dev*>(module_->GetPluginInterface(
+        static_cast<const PPP_Printing_Dev*>(module_->GetPluginInterface(
             PPP_PRINTING_DEV_INTERFACE));
   }
   if (!plugin_print_interface_)
     return false;
   uint32_t format_count = 0;
   PP_PrintOutputFormat_Dev* supported_formats =
       plugin_print_interface_->QuerySupportedFormats(pp_instance(),
                                                      &format_count);
   if (!supported_formats)
     return false;
@@ skipping 478 matching lines @@
   return found->second;
 }
 
 bool PluginInstance::IsFullPagePlugin() const {
   WebFrame* frame = container()->element().document().frame();
   return frame->view()->mainFrame()->document().isPluginDocument();
 }
 
 }  // namespace ppapi
 }  // namespace webkit