Add PPB_Fullscreen;0.5.

ppapi/proxy/ppb_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/ppb_instance_proxy.h"
 
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/pp_var.h"
+#include "ppapi/c/ppb_fullscreen.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppb_messaging.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/serialized_var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/thunk.h"
 
@@ skipping 71 matching lines @@
     false,
     &CreateInstanceProxy,
   };
   return &info;
 }
 
 // static
 const InterfaceProxy::Info* PPB_Instance_Proxy::GetInfoFullscreen() {
   static const Info info = {
     ppapi::thunk::GetPPB_Fullscreen_Thunk(),
+    PPB_FULLSCREEN_INTERFACE,
+    INTERFACE_ID_NONE,  // 1_0 is the canonical one.
+    false,
+    &CreateInstanceProxy,
+  };
+  return &info;
+}
+
+const InterfaceProxy::Info* PPB_Instance_Proxy::GetInfoFullscreen_Dev() {
+  static const Info info = {
+    ppapi::thunk::GetPPB_Fullscreen_Dev_Thunk(),
     PPB_FULLSCREEN_DEV_INTERFACE,
     INTERFACE_ID_NONE,  // 1_0 is the canonical one.
     false,
     &CreateInstanceProxy,
   };
   return &info;
 }
 
 bool PPB_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
   // Prevent the dispatcher from going away during a call to ExecuteScript.
@@ skipping 11 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_BindGraphics,
                         OnMsgBindGraphics)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_IsFullFrame,
                         OnMsgIsFullFrame)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ExecuteScript,
                         OnMsgExecuteScript)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PostMessage,
                         OnMsgPostMessage)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetFullscreen,
                         OnMsgSetFullscreen)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetFullscreen_Dev,
+                        OnMsgSetFullscreen_Dev)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetScreenSize,
                         OnMsgGetScreenSize)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetScreenSize_Dev,
+                        OnMsgGetScreenSize_Dev)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_RequestInputEvents,
                         OnMsgRequestInputEvents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
                         OnMsgClearInputEvents)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 PPB_Instance_FunctionAPI* PPB_Instance_Proxy::AsPPB_Instance_FunctionAPI() {
@@ skipping 49 matching lines @@
 }
 
 PP_Bool PPB_Instance_Proxy::IsFullscreen(PP_Instance instance) {
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return PP_FALSE;
   return data->fullscreen;
 }
 
+PP_Bool PPB_Instance_Proxy::IsFullscreen_Dev(PP_Instance instance) {
+  return IsFullscreen(instance);
+}
+
 PP_Bool PPB_Instance_Proxy::SetFullscreen(PP_Instance instance,
                                           PP_Bool fullscreen) {
   PP_Bool result = PP_FALSE;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetFullscreen(
       INTERFACE_ID_PPB_INSTANCE, instance, fullscreen, &result));
   return result;
 }
 
+PP_Bool PPB_Instance_Proxy::SetFullscreen_Dev(PP_Instance instance,
+                                              PP_Bool fullscreen) {
+  PP_Bool result = PP_FALSE;
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetFullscreen_Dev(
+      INTERFACE_ID_PPB_INSTANCE, instance, fullscreen, &result));
+  return result;
+}
+
 PP_Bool PPB_Instance_Proxy::GetScreenSize(PP_Instance instance,
                                           PP_Size* size) {
   PP_Bool result = PP_FALSE;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetScreenSize(
       INTERFACE_ID_PPB_INSTANCE, instance, &result, size));
   return result;
 }
 
+PP_Bool PPB_Instance_Proxy::GetScreenSize_Dev(PP_Instance instance,
+                                              PP_Size* size) {
+  PP_Bool result = PP_FALSE;
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetScreenSize_Dev(
+      INTERFACE_ID_PPB_INSTANCE, instance, &result, size));
+  return result;
+}
+
 int32_t PPB_Instance_Proxy::RequestInputEvents(PP_Instance instance,
                                                uint32_t event_classes) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_RequestInputEvents(
       INTERFACE_ID_PPB_INSTANCE, instance, false, event_classes));
 
   // We always register for the classes we can handle, this function validates
   // the flags so we can notify it if anything was invalid, without requiring
   // a sync reply.
   return ValidateRequestInputEvents(false, event_classes);
 }
@@ skipping 97 matching lines @@
 }
 
 void PPB_Instance_Proxy::OnMsgSetFullscreen(PP_Instance instance,
                                             PP_Bool fullscreen,
                                             PP_Bool* result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->SetFullscreen(instance, fullscreen);
 }
 
+void PPB_Instance_Proxy::OnMsgSetFullscreen_Dev(PP_Instance instance,
+                                                PP_Bool fullscreen,
+                                                PP_Bool* result) {
+  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  if (enter.succeeded())
+    *result = enter.functions()->SetFullscreen_Dev(instance, fullscreen);
+}
+
 void PPB_Instance_Proxy::OnMsgGetScreenSize(PP_Instance instance,
                                             PP_Bool* result,
                                             PP_Size* size) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->GetScreenSize(instance, size);
 }
 
+void PPB_Instance_Proxy::OnMsgGetScreenSize_Dev(PP_Instance instance,
+                                                PP_Bool* result,
+                                                PP_Size* size) {
+  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  if (enter.succeeded())
+    *result = enter.functions()->GetScreenSize_Dev(instance, size);
+}
+
 void PPB_Instance_Proxy::OnMsgRequestInputEvents(PP_Instance instance,
                                                  bool is_filtering,
                                                  uint32_t event_classes) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded()) {
     if (is_filtering)
       enter.functions()->RequestFilteringInputEvents(instance, event_classes);
     else
       enter.functions()->RequestInputEvents(instance, event_classes);
   }
 }
 
 void PPB_Instance_Proxy::OnMsgClearInputEvents(PP_Instance instance,
                                                uint32_t event_classes) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded())
     enter.functions()->ClearInputEventRequest(instance, event_classes);
 }
 
 void PPB_Instance_Proxy::OnMsgPostMessage(PP_Instance instance,
                                           SerializedVarReceiveInput message) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded())
     enter.functions()->PostMessage(instance, message.Get(dispatcher()));
 }
 
 }  // namespace proxy
 }  // namespace ppapi