Implement asynchronous interface/plumbing for GetDefaultPrintSettings.

ppapi/proxy/ppb_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/ppb_instance_proxy.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_time.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_audio_config.h"
@@ skipping 106 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_RequestInputEvents,
                         OnHostMsgRequestInputEvents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
                         OnHostMsgClearInputEvents)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInputEvent_HandleInputEvent_ACK,
                         OnMsgHandleInputEventAck)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_LockMouse,
                         OnHostMsgLockMouse)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UnlockMouse,
                         OnHostMsgUnlockMouse)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBPInstance_GetDefaultPrintSettings,
-                        OnHostMsgGetDefaultPrintSettings)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetCursor,
                         OnHostMsgSetCursor)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTextInputType,
                         OnHostMsgSetTextInputType)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateCaretPosition,
                         OnHostMsgUpdateCaretPosition)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_CancelCompositionText,
                         OnHostMsgCancelCompositionText)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateSurroundingText,
                         OnHostMsgUpdateSurroundingText)
 #if !defined(OS_NACL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ResolveRelativeToDocument,
                         OnHostMsgResolveRelativeToDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanRequest,
                         OnHostMsgDocumentCanRequest)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanAccessDocument,
                         OnHostMsgDocumentCanAccessDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDocumentURL,
                         OnHostMsgGetDocumentURL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginInstanceURL,
                         OnHostMsgGetPluginInstanceURL)
 #endif  // !defined(OS_NACL)
 
     // Host -> Plugin messages.
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBInstance_MouseLockComplete,
                         OnPluginMsgMouseLockComplete)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBInstance_GetDefaultPrintSettingsComplete,
+                        OnPluginMsgGetDefaultPrintSettingsComplete)
 
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 PP_Bool PPB_Instance_Proxy::BindGraphics(PP_Instance instance,
                                          PP_Resource device) {
   Resource* object =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(device);
@@ skipping 285 matching lines @@
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_LockMouse(
       API_ID_PPB_INSTANCE, instance));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_Instance_Proxy::UnlockMouse(PP_Instance instance) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_UnlockMouse(
       API_ID_PPB_INSTANCE, instance));
 }
 
-PP_Bool PPB_Instance_Proxy::GetDefaultPrintSettings(
+int32_t PPB_Instance_Proxy::GetDefaultPrintSettings(
     PP_Instance instance,
-    PP_PrintSettings_Dev* print_settings) {
+    PP_PrintSettings_Dev* print_settings,
+    scoped_refptr<TrackedCallback> callback) {
   if (!print_settings)
-    return PP_FALSE;
+    return PP_ERROR_BADARGUMENT;
+  PluginDispatcher* plugin_dispatcher =
+      static_cast<PluginDispatcher*>(dispatcher());
+  InstanceData* data = plugin_dispatcher->GetInstanceData(instance);
+  if (!data)
+    return PP_ERROR_BADARGUMENT;
+  if (TrackedCallback::IsPending(data->default_print_settings_callback))
+    return PP_ERROR_INPROGRESS;  // Already have a pending callback.
+  data->default_print_settings_callback = callback;
+  data->default_print_settings = print_settings;
 
-  bool result;
-  dispatcher()->Send(new PpapiHostMsg_PPBPInstance_GetDefaultPrintSettings(
-      API_ID_PPB_INSTANCE, instance, print_settings, &result));
+  PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+      new PpapiHostMsg_PPBPInstance_GetDefaultPrintSettings(
+          API_ID_PPB_INSTANCE, plugin_dispatcher->plugin_dispatcher_id(),
+          instance));
 
-  return PP_FromBool(result);
+  return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_Instance_Proxy::SetTextInputType(PP_Instance instance,
                                           PP_TextInput_Type type) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetTextInputType(
       API_ID_PPB_INSTANCE, instance, type));
 }
 
 void PPB_Instance_Proxy::UpdateCaretPosition(PP_Instance instance,
                                              const PP_Rect& caret,
@@ skipping 168 matching lines @@
   if (enter.succeeded())
     enter.SetResult(enter.functions()->LockMouse(instance, enter.callback()));
 }
 
 void PPB_Instance_Proxy::OnHostMsgUnlockMouse(PP_Instance instance) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     enter.functions()->UnlockMouse(instance);
 }
 
-void PPB_Instance_Proxy::OnHostMsgGetDefaultPrintSettings(
-    PP_Instance instance,
-    PP_PrintSettings_Dev* settings,
-    bool* result) {
-  // TODO(raymes): This just returns some generic settings. Actually hook this
-  // up to the browser to return the real defaults.
-  PP_PrintSettings_Dev default_settings = {
-      // |printable_area|: all of the sheet of paper.
-      { { 0, 0 }, { 612, 792 } },
-      // |content_area|: 0.5" margins all around.
-      { { 36, 36 }, { 540, 720 } },
-      // |paper_size|: 8.5" x 11" (US letter).
-      { 612, 792 },
-      300,  // |dpi|.
-      PP_PRINTORIENTATION_NORMAL,  // |orientation|.
-      PP_PRINTSCALINGOPTION_NONE,  // |print_scaling_option|.
-      PP_FALSE,  // |grayscale|.
-      PP_PRINTOUTPUTFORMAT_PDF  // |format|.
-  };
-  *settings = default_settings;
-  *result = true;
-}
-
 #if !defined(OS_NACL)
 void PPB_Instance_Proxy::OnHostMsgResolveRelativeToDocument(
     PP_Instance instance,
     SerializedVarReceiveInput relative,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->ResolveRelativeToDocument(
                       instance, relative.Get(dispatcher()), NULL));
@@ skipping 100 matching lines @@
   }
   TrackedCallback::ClearAndRun(&(data->mouse_lock_callback), result);
 }
 
 void PPB_Instance_Proxy::MouseLockCompleteInHost(int32_t result,
                                                  PP_Instance instance) {
   dispatcher()->Send(new PpapiMsg_PPBInstance_MouseLockComplete(
       API_ID_PPB_INSTANCE, instance, result));
 }
 
+void PPB_Instance_Proxy::OnPluginMsgGetDefaultPrintSettingsComplete(
+    int32 routing_id,
+    PP_Instance instance,
+    const PP_PrintSettings_Dev& settings,
+    int32_t result) {
+  InstanceData* data =
+      static_cast<PluginDispatcher*>(dispatcher())->GetInstanceData(instance);
+  if (!data)
+    return;  // Instance was probably deleted.

[dmichael (off chromium), 2012/07/23 18:20:09]

The callback was probably already run in this case, but maybe it would be good
to ClearAndAbort it anyway (at the very least, this will release our reference
on it). If it's already been run, it won't be run again.

[raymes, 2012/07/24 00:37:08]

Our callback is stored in the instance data so if we can't get the instance
data, we can't access the callback. However, if the instance data is gone,
presumably the reference to the callback is released anyway?

On 2012/07/23 18:20:09, dmichael wrote:

+  if (!TrackedCallback::IsPending(data->default_print_settings_callback) ||
+      !data->default_print_settings) {
+    NOTREACHED();
+    return;
+  }
+  *data->default_print_settings = settings;
+  TrackedCallback::ClearAndRun(
+      &(data->default_print_settings_callback), result);
+}
+
 }  // namespace proxy
 }  // namespace ppapi