Add PPB_Fullscreen;0.5.

ppapi/proxy/ppp_instance_proxy.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 "ppapi/proxy/ppp_instance_proxy.h"
 
 #include <algorithm>
 
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
@@ skipping 34 matching lines @@
 }
 
 void DidChangeView(PP_Instance instance,
                    const PP_Rect* position,
                    const PP_Rect* clip) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   const PPB_FlashFullscreen* fullscreen_interface =
       static_cast<const PPB_FlashFullscreen*>(
           dispatcher->local_get_interface()(PPB_FLASHFULLSCREEN_INTERFACE));
   DCHECK(fullscreen_interface);
+  const PPB_FlashFullscreen* flash_fullscreen_interface =
+      static_cast<const PPB_FlashFullscreen*>(
+          dispatcher->local_get_interface()(PPB_FLASHFULLSCREEN_INTERFACE));
+  DCHECK(flash_fullscreen_interface);
   PP_Bool fullscreen = fullscreen_interface->IsFullscreen(instance);
+  PP_Bool flash_fullscreen  =
+      flash_fullscreen_interface->IsFullscreen(instance);
   dispatcher->Send(
       new PpapiMsg_PPPInstance_DidChangeView(INTERFACE_ID_PPP_INSTANCE,
                                              instance, *position, *clip,
-                                             fullscreen));
+                                             fullscreen,
+                                             flash_fullscreen));
 }
 
 void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) {
   HostDispatcher::GetForInstance(instance)->Send(
       new PpapiMsg_PPPInstance_DidChangeFocus(INTERFACE_ID_PPP_INSTANCE,
                                               instance, has_focus));
 }
 
 PP_Bool HandleDocumentLoad(PP_Instance instance,
                            PP_Resource url_loader) {
@@ skipping 119 matching lines @@
 
 void PPP_Instance_Proxy::OnMsgDidDestroy(PP_Instance instance) {
   combined_interface_->DidDestroy(instance);
   ppapi::TrackerBase::Get()->GetResourceTracker()->DidDeleteInstance(instance);
   static_cast<PluginDispatcher*>(dispatcher())->DidDestroyInstance(instance);
 }
 
 void PPP_Instance_Proxy::OnMsgDidChangeView(PP_Instance instance,
                                             const PP_Rect& position,
                                             const PP_Rect& clip,
-                                            PP_Bool fullscreen) {
+                                            PP_Bool fullscreen,
+                                            PP_Bool flash_fullscreen) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
   InstanceData* data = dispatcher->GetInstanceData(instance);
   if (!data)
     return;
   data->position = position;
   data->fullscreen = fullscreen;
+  data->flash_fullscreen = flash_fullscreen;
   combined_interface_->DidChangeView(instance, &position, &clip);
 }
 
 void PPP_Instance_Proxy::OnMsgDidChangeFocus(PP_Instance instance,
                                              PP_Bool has_focus) {
   combined_interface_->DidChangeFocus(instance, has_focus);
 }
 
 void PPP_Instance_Proxy::OnMsgHandleDocumentLoad(PP_Instance instance,
                                                  const HostResource& url_loader,
                                                  PP_Bool* result) {
   PP_Resource plugin_loader =
       PPB_URLLoader_Proxy::TrackPluginResource(url_loader);
   *result = combined_interface_->HandleDocumentLoad(instance, plugin_loader);
 
   // This balances the one reference that TrackPluginResource() initialized it
   // 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.
   PluginResourceTracker::GetInstance()->ReleaseResource(plugin_loader);
 }
 
 }  // namespace proxy
 }  // namespace ppapi