Refactor PPB_Flash_Fullscreen to the new resource model.

ppapi/proxy/ppp_instance_proxy.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 "ppapi/proxy/ppp_instance_proxy.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_fullscreen.h"
 #include "ppapi/c/ppp_instance.h"
-#include "ppapi/c/private/ppb_flash_fullscreen.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_url_loader_proxy.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_flash_fullscreen_api.h"
 #include "ppapi/thunk/ppb_view_api.h"
 
 namespace ppapi {
 namespace proxy {
 
+using thunk::EnterInstanceAPINoLock;
+using thunk::EnterInstanceNoLock;
+using thunk::EnterResourceNoLock;
+using thunk::PPB_Flash_Fullscreen_API;
+using thunk::PPB_Instance_API;
+using thunk::PPB_View_API;
+
 namespace {
 
 #if !defined(OS_NACL)
-PP_Bool IsFlashFullscreen(PP_Instance instance,
-                          HostDispatcher* dispatcher) {
-  const PPB_FlashFullscreen* flash_fullscreen_interface =
-      static_cast<const PPB_FlashFullscreen*>(
-          dispatcher->local_get_interface()(PPB_FLASHFULLSCREEN_INTERFACE));
-  DCHECK(flash_fullscreen_interface);
-  return flash_fullscreen_interface->IsFullscreen(instance);
-}
-
 PP_Bool DidCreate(PP_Instance instance,
                   uint32_t argc,
                   const char* argn[],
                   const char* argv[]) {
   std::vector<std::string> argn_vect;
   std::vector<std::string> argv_vect;
   for (uint32_t i = 0; i < argc; i++) {
     argn_vect.push_back(std::string(argn[i]));
     argv_vect.push_back(std::string(argv[i]));
   }
 
   PP_Bool result = PP_FALSE;
   HostDispatcher::GetForInstance(instance)->Send(
       new PpapiMsg_PPPInstance_DidCreate(API_ID_PPP_INSTANCE, instance,
                                          argn_vect, argv_vect, &result));
   return result;
 }
 
 void DidDestroy(PP_Instance instance) {
   HostDispatcher::GetForInstance(instance)->Send(
       new PpapiMsg_PPPInstance_DidDestroy(API_ID_PPP_INSTANCE, instance));
 }
 
 void DidChangeView(PP_Instance instance, PP_Resource view_resource) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 
-  thunk::EnterResourceNoLock<thunk::PPB_View_API> enter(view_resource, false);
-  if (enter.failed()) {
+  EnterResourceNoLock<PPB_View_API> enter_view(view_resource, false);
+  if (enter_view.failed()) {
     NOTREACHED();
     return;
   }
 
+  PP_Bool flash_fullscreen = PP_FALSE;
+  EnterInstanceNoLock enter_instance(instance);
+  if (!enter_instance.failed())
+    flash_fullscreen = enter_instance.functions()->FlashIsFullscreen(instance);
   dispatcher->Send(new PpapiMsg_PPPInstance_DidChangeView(
-      API_ID_PPP_INSTANCE, instance, enter.object()->GetData(),
-      IsFlashFullscreen(instance, dispatcher)));
+      API_ID_PPP_INSTANCE, instance, enter_view.object()->GetData(),
+      flash_fullscreen));
 }
 
 void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) {
   HostDispatcher::GetForInstance(instance)->Send(
       new PpapiMsg_PPPInstance_DidChangeFocus(API_ID_PPP_INSTANCE,
                                               instance, has_focus));
 }
 
 PP_Bool HandleDocumentLoad(PP_Instance instance,
                            PP_Resource url_loader) {
@@ skipping 130 matching lines @@
 void PPP_Instance_Proxy::OnPluginMsgDidChangeView(
     PP_Instance instance,
     const ViewData& new_data,
     PP_Bool flash_fullscreen) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
   InstanceData* data = dispatcher->GetInstanceData(instance);
   if (!data)
     return;
+  data->view = new_data;
 
-  data->view = new_data;
-  data->flash_fullscreen = flash_fullscreen;
+#if !defined(OS_NACL)
+  EnterInstanceAPINoLock<PPB_Flash_Fullscreen_API> enter(instance);
+  if (!enter.failed())
+    enter.functions()->SetLocalIsFullscreen(instance, flash_fullscreen);
+#endif  // !defined(OS_NACL)
 
   ScopedPPResource resource(
       ScopedPPResource::PassRef(),
       (new PPB_View_Shared(OBJECT_IS_PROXY,
                            instance, new_data))->GetReference());
 
   combined_interface_->DidChangeView(instance, resource,
                                      &new_data.rect,
                                      &new_data.clip_rect);
 }
@@ skipping 15 matching lines @@
   // with. The plugin will normally take an additional reference which will keep
   // the resource alive in the plugin (and the one reference in the renderer
   // representing all plugin references).
   // Once all references at the plugin side are released, the renderer side will
   // be notified and release the reference added in HandleDocumentLoad() above.
   PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(plugin_loader);
 }
 
 }  // namespace proxy
 }  // namespace ppapi