Implement an IsAllowed function in the pepper PPB_Broker_Trusted API

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 290 matching lines @@
   scoped_array<const char*> array(new const char*[vector.size()]);
   for (size_t i = 0; i < vector.size(); ++i)
     array[i] = vector[i].c_str();
   return array.Pass();
 }
 
 }  // namespace
 
 // static
 PluginInstance* PluginInstance::Create(PluginDelegate* delegate,
-                                       PluginModule* module) {
+                                       PluginModule* module,
+                                       WebPluginContainer* container,
+                                       const GURL& plugin_url) {
   base::Callback<const void*(const char*)> get_plugin_interface_func =
       base::Bind(&PluginModule::GetPluginInterface, module);
   PPP_Instance_Combined* ppp_instance_combined =
       PPP_Instance_Combined::Create(get_plugin_interface_func);
   if (!ppp_instance_combined)
     return NULL;
-  return new PluginInstance(delegate, module, ppp_instance_combined);
+  return new PluginInstance(delegate, module, ppp_instance_combined, container,
+                            plugin_url);
 }
 
 PluginInstance::GamepadImpl::GamepadImpl(PluginDelegate* delegate)
     : Resource(::ppapi::Resource::Untracked()),
       delegate_(delegate) {
 }
 
 PPB_Gamepad_API* PluginInstance::GamepadImpl::AsPPB_Gamepad_API() {
   return this;
 }
 
 void PluginInstance::GamepadImpl::Sample(PP_GamepadsSampleData* data) {
   WebKit::WebGamepads webkit_data;
   delegate_->SampleGamepads(&webkit_data);
   ConvertWebKitGamepadData(
       *reinterpret_cast<const ::ppapi::WebKitGamepads*>(&webkit_data), data);
 }
 
 PluginInstance::PluginInstance(
     PluginDelegate* delegate,
     PluginModule* module,
-    ::ppapi::PPP_Instance_Combined* instance_interface)
+    ::ppapi::PPP_Instance_Combined* instance_interface,
+    WebPluginContainer* container,
+    const GURL& plugin_url)
     : delegate_(delegate),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
-      container_(NULL),
+      container_(container),
+      plugin_url_(plugin_url),
       full_frame_(false),
       sent_initial_did_change_view_(false),
       view_change_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       bound_graphics_2d_platform_(NULL),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
       plugin_find_interface_(NULL),
       plugin_input_event_interface_(NULL),
       plugin_messaging_interface_(NULL),
@@ skipping 197 matching lines @@
   // 3 : 3D content and GPU is not blacklisted
   // 4 : No 3D content and GPU is blacklisted on XP
   // 5 : No 3D content and GPU is not blacklisted on XP
   // 6 : 3D content but GPU is blacklisted on XP
   // 7 : 3D content and GPU is not blacklisted on XP
   UMA_HISTOGRAM_ENUMERATION("Flash.UsesGPU",
       is_xp * 4 + needs_gpu * 2 + prefs.is_webgl_supported, 8);
 #endif
 }
 
-bool PluginInstance::Initialize(WebPluginContainer* container,
-                                const std::vector<std::string>& arg_names,
+bool PluginInstance::Initialize(const std::vector<std::string>& arg_names,
                                 const std::vector<std::string>& arg_values,
-                                const GURL& plugin_url,
                                 bool full_frame) {
-  container_ = container;
-  plugin_url_ = plugin_url;
   full_frame_ = full_frame;
 
   UpdateTouchEventRequest();
   container_->setWantsWheelEvents(IsAcceptingWheelEvents());
 
   SetGPUHistogram(delegate_->GetPreferences(), arg_names, arg_values);
 
   argn_ = arg_names;
   argv_ = arg_values;
   scoped_array<const char*> argn_array(StringVectorToArgArray(argn_));
@@ skipping 1543 matching lines @@
   return PP_TRUE;
 }
 
 ::ppapi::thunk::PPB_Flash_API* PluginInstance::GetFlashAPI() {
   return &flash_impl_;
 }
 
 ::ppapi::Resource* PluginInstance::GetSingletonResource(
     PP_Instance instance,
     ::ppapi::SingletonResourceID id) {
-  // Flash APIs aren't implemented in-process.
+  // Flash APIs and some others aren't implemented in-process.
   switch (id) {
+    case ::ppapi::BROKER_SINGLETON_ID:
     case ::ppapi::FLASH_CLIPBOARD_SINGLETON_ID:
     case ::ppapi::FLASH_FILE_SINGLETON_ID:
     case ::ppapi::FLASH_FULLSCREEN_SINGLETON_ID:
     case ::ppapi::FLASH_SINGLETON_ID:
       NOTIMPLEMENTED();
       return NULL;
     case ::ppapi::GAMEPAD_SINGLETON_ID:
       return gamepad_impl_;
   }
 
@@ skipping 334 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit