From 2272ed3505a36c7d1543f24b770ea85dcfee8640 Mon Sep 17 00:00:00 2001
From: "neb@chromium.org"
<neb@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>
Date: Wed, 30 Mar 2011 17:37:54 +0000
Subject: IDL version of PPAPI interfaces.
BUG=none
TEST=none yet... soon.
Review URL: http://codereview.chromium.org/6726041
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@79857 0039d316-1c4b-4281-b951-d872f2087c98
---
ppapi/api/pp_bool.idl | 16 ++
ppapi/api/pp_completion_callback.idl | 29 ++++
ppapi/api/pp_errors.idl | 57 +++++++
ppapi/api/pp_input_event.idl | 227 ++++++++++++++++++++++++++
ppapi/api/pp_instance.idl | 18 ++
ppapi/api/pp_module.idl | 16 ++
ppapi/api/pp_point.idl | 20 +++
ppapi/api/pp_rect.idl | 14 ++
ppapi/api/pp_resource.idl | 21 +++
ppapi/api/pp_size.idl | 14 ++
ppapi/api/pp_time.idl | 23 +++
ppapi/api/pp_var.idl | 56 +++++++
ppapi/api/ppb.idl | 19 +++
ppapi/api/ppb_audio.idl | 72 ++++++++
ppapi/api/ppb_audio_config.idl | 96 +++++++++++
ppapi/api/ppb_core.idl | 69 ++++++++
ppapi/api/ppb_graphics_2d.idl | 196 ++++++++++++++++++++++
ppapi/api/ppb_image_data.idl | 86 ++++++++++
ppapi/api/ppb_instance.idl | 55 +++++++
ppapi/api/ppb_url_loader.idl | 117 +++++++++++++
ppapi/api/ppb_url_request_info.idl | 92 +++++++++++
ppapi/api/ppb_url_response_info.idl | 49 ++++++
ppapi/api/ppb_var.idl | 69 ++++++++
ppapi/api/ppp_instance.idl | 155 ++++++++++++++++++
ppapi/api/private/ppb_flash.idl | 60 +++++++
ppapi/api/private/ppb_flash_file.idl | 81 +++++++++
ppapi/api/private/ppb_flash_menu.idl | 52 ++++++
ppapi/api/private/ppb_flash_net_connector.idl | 41 +++++
ppapi/api/private/ppb_nacl_private.idl | 28 ++++
ppapi/api/private/ppb_pdf.idl | 141 ++++++++++++++++
ppapi/api/private/ppb_proxy_private.idl | 17 ++
ppapi/api/trusted/ppb_audio_trusted.idl | 43 +++++
ppapi/api/trusted/ppb_image_data_trusted.idl | 20 +++
ppapi/api/trusted/ppb_url_loader_trusted.idl | 40 +++++
34 files changed, 2109 insertions(+)
create mode 100644 ppapi/api/pp_bool.idl
create mode 100644 ppapi/api/pp_completion_callback.idl
create mode 100644 ppapi/api/pp_errors.idl
create mode 100644 ppapi/api/pp_input_event.idl
create mode 100644 ppapi/api/pp_instance.idl
create mode 100644 ppapi/api/pp_module.idl
create mode 100644 ppapi/api/pp_point.idl
create mode 100644 ppapi/api/pp_rect.idl
create mode 100644 ppapi/api/pp_resource.idl
create mode 100644 ppapi/api/pp_size.idl
create mode 100644 ppapi/api/pp_time.idl
create mode 100644 ppapi/api/pp_var.idl
create mode 100644 ppapi/api/ppb.idl
create mode 100644 ppapi/api/ppb_audio.idl
create mode 100644 ppapi/api/ppb_audio_config.idl
create mode 100644 ppapi/api/ppb_core.idl
create mode 100644 ppapi/api/ppb_graphics_2d.idl
create mode 100644 ppapi/api/ppb_image_data.idl
create mode 100644 ppapi/api/ppb_instance.idl
create mode 100644 ppapi/api/ppb_url_loader.idl
create mode 100644 ppapi/api/ppb_url_request_info.idl
create mode 100644 ppapi/api/ppb_url_response_info.idl
create mode 100644 ppapi/api/ppb_var.idl
create mode 100644 ppapi/api/ppp_instance.idl
create mode 100644 ppapi/api/private/ppb_flash.idl
create mode 100644 ppapi/api/private/ppb_flash_file.idl
create mode 100644 ppapi/api/private/ppb_flash_menu.idl
create mode 100644 ppapi/api/private/ppb_flash_net_connector.idl
create mode 100644 ppapi/api/private/ppb_nacl_private.idl
create mode 100644 ppapi/api/private/ppb_pdf.idl
create mode 100644 ppapi/api/private/ppb_proxy_private.idl
create mode 100644 ppapi/api/trusted/ppb_audio_trusted.idl
create mode 100644 ppapi/api/trusted/ppb_image_data_trusted.idl
create mode 100644 ppapi/api/trusted/ppb_url_loader_trusted.idl
(limited to 'ppapi/api')
diff --git a/ppapi/api/pp_bool.idl b/ppapi/api/pp_bool.idl
new file mode 100644
index 0000000..61d0b5c
--- /dev/null
+++ b/ppapi/api/pp_bool.idl
@@ -0,0 +1,16 @@
+/* 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.
+ */
+
+/* This file defines the PP_Bool enumeration for use in PPAPI C headers. */
+
+/* The PP_Bool enum is a boolean value for use in PPAPI C headers. The
+ * standard bool type is not available to pre-C99 compilers, and is not
+ * guaranteed to be compatible between C and C++, whereas the PPAPI C
+ * headers can be included from C or C++ code.
+ */
+enum PP_Bool {
+ PP_FALSE = 0,
+ PP_TRUE = 1
+};
diff --git a/ppapi/api/pp_completion_callback.idl b/ppapi/api/pp_completion_callback.idl
new file mode 100644
index 0000000..b1fb8b3
--- /dev/null
+++ b/ppapi/api/pp_completion_callback.idl
@@ -0,0 +1,29 @@
+/* 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.
+ */
+
+/* This file defines the completion callback type. */
+
+/* The callback function. */
+typedef void PP_CompletionCallback_Func([in] mem_t user_data,
+ [in] int32_t result);
+
+/* Any method that takes a PP_CompletionCallback has the option of completing
+ * asynchronously if the operation would block. Such a method should return
+ * PP_Error_WouldBlock to indicate when the method will complete
+ * asynchronously. If the completion callback is NULL, then the operation
+ * will block if necessary to complete its work. PP_BlockUntilComplete()
+ * provides a convenient way to specify blocking behavior.
+ *
+ * The result parameter passes an int32_t that if negative indicates an error
+ * code. Otherwise the result value indicates success. If it is a positive
+ * value then it may carry additional information.
+ */
+[passByValue] struct PP_CompletionCallback {
+ /* Function to call during callback. */
+ PP_CompletionCallback_Func func;
+
+ /* Data to pass into callback. */
+ mem_t user_data;
+};
diff --git a/ppapi/api/pp_errors.idl b/ppapi/api/pp_errors.idl
new file mode 100644
index 0000000..59db3455
--- /dev/null
+++ b/ppapi/api/pp_errors.idl
@@ -0,0 +1,57 @@
+/* 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.
+ */
+
+/* This file defines an enumeration of all PPAPI errors. */
+
+/* This enumeration contains enumerators of all PPAPI errors.
+ * Errors are negative valued.
+ */
+enum PP_Error {
+ PP_OK = 0,
+ /* This value is returned by a function that accepts a PP_CompletionCallback
+ * and cannot complete synchronously. This error indicates that the given
+ * callback will be asynchronously notified of the final result once it is
+ * available.
+ */
+ PP_ERROR_WOULDBLOCK = -1,
+ /* This value indicates failure for unspecified reasons. */
+ PP_ERROR_FAILED = -2,
+ /* This value indicates failure due to an asynchronous operation being
+ * interrupted, typically as a result of user action. */
+ PP_ERROR_ABORTED = -3,
+ /* This value indicates failure due to an invalid argument. */
+ PP_ERROR_BADARGUMENT = -4,
+ /* This value indicates failure due to an invalid PP_Resource. */
+ PP_ERROR_BADRESOURCE = -5,
+ /* This value indicates failure due to an unavailable PPAPI interface. */
+ PP_ERROR_NOINTERFACE = -6,
+ /* This value indicates failure due to insufficient privileges. */
+ PP_ERROR_NOACCESS = -7,
+ /* This value indicates failure due to insufficient memory. */
+ PP_ERROR_NOMEMORY = -8,
+ /* This value indicates failure due to insufficient storage space. */
+ PP_ERROR_NOSPACE = -9,
+ /* This value indicates failure due to insufficient storage quota. */
+ PP_ERROR_NOQUOTA = -10,
+ /* This value indicates failure due to an action already being in progress. */
+ PP_ERROR_INPROGRESS = -11,
+ /* This value indicates failure due to a file that does not exist. */
+ PP_ERROR_FILENOTFOUND = -20,
+ /* This value indicates failure due to a file that already exists. */
+ PP_ERROR_FILEEXISTS = -21,
+ /* This value indicates failure due to a file that is too big. */
+ PP_ERROR_FILETOOBIG = -22,
+ /* This value indicates failure due to a file having been modified
+ * unexpectedly.
+ */
+ PP_ERROR_FILECHANGED = -23,
+ /* This value indicates failure due to a time limit being exceeded. */
+ PP_ERROR_TIMEDOUT = -30,
+ /* This value indicates that the user cancelled rather than providing expected
+ * input.
+ */
+ PP_ERROR_USERCANCEL = -40
+};
+
diff --git a/ppapi/api/pp_input_event.idl b/ppapi/api/pp_input_event.idl
new file mode 100644
index 0000000..fdb53a7
--- /dev/null
+++ b/ppapi/api/pp_input_event.idl
@@ -0,0 +1,227 @@
+/* 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.
+ */
+
+/* This file defines the API used to handle mouse and keyboard input events. */
+
+/* This enumeration contains constants representing each mouse button. */
+enum PP_InputEvent_MouseButton {
+ PP_INPUTEVENT_MOUSEBUTTON_NONE = -1,
+ PP_INPUTEVENT_MOUSEBUTTON_LEFT = 0,
+ PP_INPUTEVENT_MOUSEBUTTON_MIDDLE = 1,
+ PP_INPUTEVENT_MOUSEBUTTON_RIGHT = 2
+};
+
+/* This enumeration contains mouse and keyboard event constants. */
+enum PP_InputEvent_Type {
+ PP_INPUTEVENT_TYPE_UNDEFINED = -1,
+ /* PP_InputEvent_Mouse */
+ PP_INPUTEVENT_TYPE_MOUSEDOWN = 0,
+ /* PP_InputEvent_Mouse */
+ PP_INPUTEVENT_TYPE_MOUSEUP = 1,
+ /* PP_InputEvent_Mouse */
+ PP_INPUTEVENT_TYPE_MOUSEMOVE = 2,
+ /* PP_InputEvent_Mouse */
+ PP_INPUTEVENT_TYPE_MOUSEENTER = 3,
+ /* PP_InputEvent_Mouse */
+ PP_INPUTEVENT_TYPE_MOUSELEAVE = 4,
+ /* PP_InputEvent_Wheel */
+ PP_INPUTEVENT_TYPE_MOUSEWHEEL = 5,
+ /* PP_InputEvent_Key */
+ PP_INPUTEVENT_TYPE_RAWKEYDOWN = 6,
+ /* PP_InputEvent_Key */
+ PP_INPUTEVENT_TYPE_KEYDOWN = 7,
+ /* PP_InputEvent_Key */
+ PP_INPUTEVENT_TYPE_KEYUP = 8,
+ /* PP_InputEvent_Character */
+ PP_INPUTEVENT_TYPE_CHAR = 9,
+ /* PP_InputEvent_Mouse */
+ PP_INPUTEVENT_TYPE_CONTEXTMENU = 10
+};
+
+/* This enumeration contains event modifier constants. */
+enum PP_InputEvent_Modifier {
+ PP_INPUTEVENT_MODIFIER_SHIFTKEY = 1 << 0,
+ PP_INPUTEVENT_MODIFIER_CONTROLKEY = 1 << 1,
+ PP_INPUTEVENT_MODIFIER_ALTKEY = 1 << 2,
+ PP_INPUTEVENT_MODIFIER_METAKEY = 1 << 3,
+ PP_INPUTEVENT_MODIFIER_ISKEYPAD = 1 << 4,
+ PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT = 1 << 5,
+ PP_INPUTEVENT_MODIFIER_LEFTBUTTONDOWN = 1 << 6,
+ PP_INPUTEVENT_MODIFIER_MIDDLEBUTTONDOWN = 1 << 7,
+ PP_INPUTEVENT_MODIFIER_RIGHTBUTTONDOWN = 1 << 8,
+ PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY = 1 << 9,
+ PP_INPUTEVENT_MODIFIER_NUMLOCKKEY = 1 << 10
+};
+
+/* The PP_InputEvent_Key struct represents a key up or key down event.
+ *
+ * Key up and key down events correspond to physical keys on the keyboard. The
+ * actual character that the user typed (if any) will be delivered in a
+ * "character" event.
+ *
+ * If the user loses focus on the module while a key is down, a key up
+ * event might not occur. For example, if the module has focus and the user
+ * presses and holds the shift key, the module will see a "shift down" message.
+ * Then if the user clicks elsewhere on the web page, the module's focus will
+ * be lost and no more input events will be delivered.
+ *
+ * If your module depends on receiving key up events, it should also handle
+ * "lost focus" as the equivalent of "all keys up."
+ */
+struct PP_InputEvent_Key {
+ /* This value is a bit field combination of the EVENT_MODIFIER flags. */
+ uint32_t modifier;
+ /* The key code.
+ *
+ * TODO(brettw) define what these actually are.
+ */
+ uint32_t key_code;
+};
+
+/* The PP_InputEvent_Character struct represents a typed character event.
+ *
+ * Normally, the program will receive a key down event, followed by a character
+ * event, followed by a key up event. The character event will have any
+ * modifier keys applied. Obvious examples are symbols, where Shift-5 gives you
+ * a '%'. The key down and up events will give you the scan code for the "5"
+ * key, and the character event will give you the '%' character.
+ *
+ * You may not get a character event for all key down events if the key doesn't
+ * generate a character. Likewise, you may actually get multiple character
+ * events in a row. For example, some locales have an accent key that modifies
+ * the next character typed. You might get this stream of events: accent down,
+ * accent up (it didn't generate a character), letter key down, letter with
+ * accent character event (it was modified by the previous accent key), letter
+ * key up. If the letter can't be combined with the accent, like an umlaut and
+ * an 'R', the system might send unlaut down, umlaut up, 'R' key down, umlaut
+ * character (can't combine it with 'R', so just send the raw unlaut so it
+ * isn't lost"), 'R' character event, 'R' key up.
+ */
+struct PP_InputEvent_Character {
+ /* A combination of the EVENT_MODIFIER flags. */
+ uint32_t modifier;
+ /* This value represents the typed character as a single null-terminated UTF-8
+ * character. Any unused bytes will be filled with null bytes. Since the
+ * maximum UTF-8 character is 4 bytes, there will always be at least one null
+ * at the end so you can treat this as a null-termianted UTF-8 string.
+ */
+ uint8_t[5] text;
+};
+
+/* The PP_InputEvent_Mouse struct represents all mouse events except
+ * mouse wheel events.
+ */
+struct PP_InputEvent_Mouse {
+ /* This value is a bit field combination of the EVENT_MODIFIER flags. */
+ uint32_t modifier;
+ /* This value represents the button that changed for mouse down or up events.
+ *
+ * This value will be PP_EVENT_MOUSEBUTTON_NONE for mouse move, enter, and
+ * leave events.
+ */
+ PP_InputEvent_MouseButton button;
+ /* This values represents the x coordinate of the mouse when the event
+ * occurred.
+ *
+ * In most, but not all, cases these coordinates will just be integers.
+ * For example, the plugin element might be arbitrarily scaled or transformed
+ * in the DOM, and translating a mouse event into the coordinate space of the
+ * plugin will give non-integer values.
+ */
+ float_t x;
+ /* This values represents the y coordinate of the mouse when the event
+ * occurred.
+ *
+ * In most, but not all, cases these coordinates will just be integers.
+ * For example, the plugin element might be arbitrarily scaled or transformed
+ * in the DOM, and translating a mouse event into the coordinate space of the
+ * plugin will give non-integer values.
+ */
+ float_t y;
+ /* TODO(brettw) figure out exactly what this means. */
+ int32_t click_count;
+};
+
+/* The PP_InputEvent_Wheel struct represents all mouse wheel events. */
+struct PP_InputEvent_Wheel {
+ /* This value represents a combination of the EVENT_MODIFIER flags. */
+ uint32_t modifier;
+ /* Indicates the amount vertically and horizontally the user has requested
+ * to scroll by with their mouse wheel. A scroll down or to the right (where
+ * the content moves up or left) is represented as positive values, and
+ * a scroll up or to the left (where the content moves down or right) is
+ * represented as negative values.
+ *
+ * The units are either in pixels (when scroll_by_page is false) or pages
+ * (when scroll_by_page is true). For example, delta_y = -3 means scroll up 3
+ * pixels when scroll_by_page is false, and scroll up 3 pages when
+ * scroll_by_page is true.
+ *
+ * This amount is system dependent and will take into account the user's
+ * preferred scroll sensitivity and potentially also nonlinear acceleration
+ * based on the speed of the scrolling.
+ *
+ * Devices will be of varying resolution. Some mice with large detents will
+ * only generate integer scroll amounts. But fractional values are also
+ * possible, for example, on some trackpads and newer mice that don't have
+ * "clicks".
+ */
+ float_t delta_x;
+ /* See delta_x. */
+ float_t delta_y;
+ /* The number of "clicks" of the scroll wheel that have produced the
+ * event. The value may have system-specific acceleration applied to it,
+ * depending on the device. The positive and negative meanings are the same
+ * as for |delta|.
+ *
+ * If you are scrolling, you probably want to use the delta values above.
+ * These tick events can be useful if you aren't doing actual scrolling and
+ * don't want or pixel values. An example may be cycling between different
+ * items in a game.
+ *
+ * You may receive fractional values for the wheel ticks if the mouse wheel
+ * is high resolution or doesn't have "clicks". If your program wants
+ * discrete events (as in the "picking items" example) you should accumulate
+ * fractional click values from multiple messages until the total value
+ * reaches positive or negative one. This should represent a similar amount
+ * of scrolling as for a mouse that has a discrete mouse wheel.
+ */
+ float_t wheel_ticks_x;
+ /* See wheel_ticks_x. */
+ float_t wheel_ticks_y;
+ /* Indicates if the scroll delta_x/delta_y indicates pages or lines to
+ * scroll by. When true, the user is requesting to scroll by pages.
+ */
+ PP_Bool scroll_by_page;
+};
+
+/* Event's data.
+ *
+ * Padding allows new events to be added without changing the size of this
+ * struct.
+ */
+[union, pad=64] struct PP_InputEventData {
+ /* Data for key events. */
+ PP_InputEvent_Key key;
+ /* Data for characted events. */
+ PP_InputEvent_Character character;
+ /* Data for mouse events. */
+ PP_InputEvent_Mouse mouse;
+ /* Data for wheel events. */
+ PP_InputEvent_Wheel wheel;
+};
+
+/* The PP_InputEvent struct represents all input events. */
+struct PP_InputEvent {
+ /* This value represents the type of the event. */
+ PP_InputEvent_Type type;
+ /* This value represents the time that this event was generated. This value
+ * is not relative to any particular epoch; the most you can do is compare
+ * time stamps.
+ */
+ PP_TimeTicks time_stamp;
+ /* This value represents the event's specific data. */
+ PP_InputEventData u;
+};
diff --git a/ppapi/api/pp_instance.idl b/ppapi/api/pp_instance.idl
new file mode 100644
index 0000000..5e861ce
--- /dev/null
+++ b/ppapi/api/pp_instance.idl
@@ -0,0 +1,18 @@
+/* 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.
+ */
+
+/* This file defines the PP_Instance type which uniquely identifies one module
+ * instance.
+ */
+
+/* The PP_Instance value uniquely identifies one instance of a module
+ * (.nexe/PP_Module). There will be one module instance for every
+ * \<embed> tag on a page.
+ *
+ * This identifier is an opaque handle assigned by the browser to the module.
+ * It is guaranteed never to be 0, so a module can initialize it to 0 to
+ * indicate a NULL handle.
+ */
+typedef int32_t PP_Instance;
diff --git a/ppapi/api/pp_module.idl b/ppapi/api/pp_module.idl
new file mode 100644
index 0000000..657bb5c
--- /dev/null
+++ b/ppapi/api/pp_module.idl
@@ -0,0 +1,16 @@
+/* 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.
+ */
+
+/* This file defines the PP_Module type which uniquely identifies the module
+ * or .nexe.
+ */
+
+/* The PP_Module value uniquely identifies the module or .nexe.
+ *
+ * This identifier is an opaque handle assigned by the browser to the module. It
+ * is guaranteed never to be 0, so a module can initialize it to 0 to
+ * indicate a "NULL handle."
+ */
+typedef int32_t PP_Module;
diff --git a/ppapi/api/pp_point.idl b/ppapi/api/pp_point.idl
new file mode 100644
index 0000000..37aeca7
--- /dev/null
+++ b/ppapi/api/pp_point.idl
@@ -0,0 +1,20 @@
+/* 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.
+ */
+
+/* This file defines the API to create a 2 dimensional point.
+ * 0,0 is the upper-left starting coordinate.
+ */
+
+/* The PP_Point structure defines the x and y coordinates of a point. */
+struct PP_Point {
+ /* The horizontal coordinate of a point, starting with 0 as the left-most
+ * coordinate.
+ */
+ int32_t x;
+ /* The vertical coordinate of a point, starting with 0 as the top-most
+ * coordinate.
+ */
+ int32_t y;
+};
diff --git a/ppapi/api/pp_rect.idl b/ppapi/api/pp_rect.idl
new file mode 100644
index 0000000..1e82998
--- /dev/null
+++ b/ppapi/api/pp_rect.idl
@@ -0,0 +1,14 @@
+/* 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.
+ */
+
+/* This file defines the APIs for creating a 2-dimensional rectangle. */
+
+/* The PP_Rect struct contains the size and location of a 2D rectangle. */
+struct PP_Rect {
+ /* The x and y coordinates of the upper-left corner of the rectangle. */
+ PP_Point point;
+ /* The width and height of the rectangle. */
+ PP_Size size;
+};
diff --git a/ppapi/api/pp_resource.idl b/ppapi/api/pp_resource.idl
new file mode 100644
index 0000000..eeed9a3
--- /dev/null
+++ b/ppapi/api/pp_resource.idl
@@ -0,0 +1,21 @@
+/* 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.
+ */
+
+/* This file defines the PP_Resource type. */
+
+/* A resource is data associated with the Pepper plugin interface. While a
+ * Var represents something callable to JS or from the plugin to the DOM, a
+ * resource has no meaning or visibility outside of the plugin interface.
+ *
+ * Resources are reference counted. Use AddRefResource and ReleaseResource to
+ * manage your reference count of a resource. The data will be automatically
+ * destroyed when the internal reference count reaches 0.
+ *
+ * Value is an opaque handle assigned by the browser to the resource. It is
+ * guaranteed never to be 0 for a valid resource, so a plugin can initialize
+ * it to 0 to indicate a "NULL handle." Some interfaces may return a NULL
+ * resource to indicate failure.
+ */
+typedef int32_t PP_Resource;
diff --git a/ppapi/api/pp_size.idl b/ppapi/api/pp_size.idl
new file mode 100644
index 0000000..2f86724
--- /dev/null
+++ b/ppapi/api/pp_size.idl
@@ -0,0 +1,14 @@
+/* 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.
+ */
+
+/* This file defines the width and height of a 2 dimenstional rectangle. */
+
+/* The PP_Size struct contains the size of a 2D rectangle. */
+struct PP_Size {
+ /* This value represents the width of the rectangle. */
+ int32_t width;
+ /* This value represents the height of the rectangle. */
+ int32_t height;
+};
diff --git a/ppapi/api/pp_time.idl b/ppapi/api/pp_time.idl
new file mode 100644
index 0000000..1b86368
--- /dev/null
+++ b/ppapi/api/pp_time.idl
@@ -0,0 +1,23 @@
+/* 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.
+ */
+
+/* This file defines time and time ticks types. */
+
+/* The PP_Time type represents the "wall clock time" according to the browser
+ * and is defined as the number of seconds since the Epoch (00:00:00 UTC,
+ * January 1, 1970).
+ */
+typedef double_t PP_Time;
+
+/* A PP_TimeTicks value represents time ticks which are measured in seconds
+ * and are used for indicating the time that certain messages were received.
+ * In contrast to PP_Time, PP_TimeTicks does not correspond to any actual
+ * wall clock time and will not change discontinuously if the user changes
+ * their computer clock.
+ *
+ * The units are in seconds, but are not measured relative to any particular
+ * epoch, so the most you can do is compare two values.
+ */
+typedef double_t PP_TimeTicks;
diff --git a/ppapi/api/pp_var.idl b/ppapi/api/pp_var.idl
new file mode 100644
index 0000000..b3139e2
--- /dev/null
+++ b/ppapi/api/pp_var.idl
@@ -0,0 +1,56 @@
+/* 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.
+ */
+
+/* This file defines the API for handling the passing of data types between
+ * your module and the page.
+ */
+
+/* PP_VarType is an enumeration of the different types that can be contained
+ * within a PP_VAR structure.
+ */
+enum PP_VarType {
+ PP_VARTYPE_UNDEFINED = 0,
+ PP_VARTYPE_NULL = 1,
+ PP_VARTYPE_BOOL = 2,
+ PP_VARTYPE_INT32 = 3,
+ PP_VARTYPE_DOUBLE = 4,
+ PP_VARTYPE_STRING = 5,
+ PP_VARTYPE_OBJECT = 6
+};
+
+/* The value of a Var. */
+[union] struct PP_VarValue {
+ /* Value if type is PP_VARTYPE_BOOL. */
+ PP_Bool as_bool;
+ /* Value if type is PP_VARTYPE_INT32. */
+ int32_t as_int;
+ /* Value if type is PP_VARTYPE_DOUBLE. */
+ double_t as_double;
+ /* Internal ID for strings and objects. The identifier is an opaque handle
+ * assigned by the browser to the plugin. It is guaranteed never to be 0,
+ * so a plugin can initialize this ID to 0 to indicate a "NULL handle."
+ */
+ int64_t as_id;
+};
+
+/* The PP_VAR struct is a variant data type and can contain any
+ * value of one of the types named in the PP_VarType enum. This structure is
+ * for passing data between native code which can be strongly typed and the
+ * browser (JavaScript) which isn't strongly typed.
+ *
+ * JavaScript has a "number" type for holding a number, and does not
+ * differentiate between floating point and integer numbers. The
+ * JavaScript operations will try to optimize operations by using
+ * integers when possible, but could end up with doubles. Therefore,
+ * you can't assume a numeric PP_Var will be the type you expect.
+ * Your code should be capable of handling either int32_t or double for
+ * numeric PP_Vars sent from JavaScript.
+ */
+[passByValue] struct PP_Var {
+ /* Type. */
+ PP_VarType type;
+ /* Type-dependent value. */
+ PP_VarValue value;
+};
diff --git a/ppapi/api/ppb.idl b/ppapi/api/ppb.idl
new file mode 100644
index 0000000..f580dcc
--- /dev/null
+++ b/ppapi/api/ppb.idl
@@ -0,0 +1,19 @@
+/* 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.
+ */
+
+/* This file defines a function pointer type for the PPB_GetInterface function.
+ */
+
+/* This function pointer type defines the signature for the PPB_GetInterface
+ * function. A generic PPB_GetInterface pointer is passed to
+ * PPP_InitializedModule when your module is loaded. You can use this pointer
+ * to request a pointer to a specific browser interface. Browser interface
+ * names are ASCII strings and are generally defined in the header file for
+ * the interface, such as PP_AUDIO_INTERFACE found in ppb.audio.h or
+ * PPB_GRAPHICS_2D_INTERFACE in ppb_graphics_2d.h.
+ *
+ * This value will be NULL if the interface is not supported on the browser.
+ */
+typedef mem_t PPB_GetInterface([in] str_t interface_name);
diff --git a/ppapi/api/ppb_audio.idl b/ppapi/api/ppb_audio.idl
new file mode 100644
index 0000000..71abad6
--- /dev/null
+++ b/ppapi/api/ppb_audio.idl
@@ -0,0 +1,72 @@
+/* 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.
+ */
+
+/* This file defines the audio API.
+ */
+
+/* Callback function type for SetCallback. */
+typedef void PPB_Audio_Callback([out] mem_t sample_buffer,
+ [in] uint32_t buffer_size_in_bytes,
+ [inout] mem_t user_data);
+
+/* Callback-based audio interface. User of audio must set the callback that will
+ * be called each time that the buffer needs to be filled.
+ *
+ * A C++ example:
+ *
+ * void audio_callback(void* sample_buffer,
+ * size_t buffer_size_in_bytes,
+ * void* user_data) {
+ * ... fill in the buffer with samples ...
+ * }
+ *
+ * uint32_t obtained;
+ * AudioConfig config(PP_AUDIOSAMPLERATE_44100, 4096, &obtained);
+ * Audio audio(config, audio_callback, NULL);
+ * audio.StartPlayback();
+ */
+interface PPB_Audio_0_5 {
+ /* Creates a paused audio interface. No sound will be heard until
+ * StartPlayback() is called. The callback is called with the buffer address
+ * and given user data whenever the buffer needs to be filled. From within the
+ * callback, you should not call PPB_Audio functions. The callback will be
+ * called on a different thread than the one which created the interface. For
+ * performance-critical applications (i.e. low-latency audio), the callback
+ * should avoid blocking or calling functions that can obtain locks, such as
+ * malloc. The layout and the size of the buffer passed to the audio callback
+ * will be determined by the device configuration and is specified in the
+ * AudioConfig documentation. If the configuration cannot be honored, or the
+ * callback is null, the function returns 0.
+ */
+ PP_Resource Create(
+ [in] PP_Instance instance,
+ [in] PP_Resource config,
+ [in] PPB_Audio_Callback audio_callback,
+ [inout] mem_t user_data);
+
+ /* Returns PP_TRUE if the given resource is an Audio resource, PP_FALSE
+ * otherwise.
+ */
+ PP_Bool IsAudio(
+ [in] PP_Resource resource);
+
+ /* Get the current configuration. */
+ PP_Resource GetCurrentConfig(
+ [in] PP_Resource audio);
+
+ /* Start the playback. Begin periodically calling the callback. If called
+ * while playback is already in progress, will return PP_TRUE and be a no-op.
+ * On error, return PP_FALSE.
+ */
+ PP_Bool StartPlayback(
+ [in] PP_Resource audio);
+
+ /* Stop the playback. If playback is already stopped, this is a no-op and
+ * returns PP_TRUE. On error, returns PP_FALSE. If a callback is in progress,
+ * StopPlayback will block until callback completes.
+ */
+ PP_Bool StopPlayback(
+ [in] PP_Resource audio);
+};
diff --git a/ppapi/api/ppb_audio_config.idl b/ppapi/api/ppb_audio_config.idl
new file mode 100644
index 0000000..2c73e03
--- /dev/null
+++ b/ppapi/api/ppb_audio_config.idl
@@ -0,0 +1,96 @@
+/* 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.
+ */
+
+/* This file defines the AudioConfig interface. */
+
+
+/**
+ * This enumeration contains audio frame count constants.
+ * PP_AUDIOMINSAMPLEFRAMECOUNT is the minimum possible frame count.
+ * PP_AUDIOMAXSAMPLEFRAMECOUNT is the maximum possible frame count.
+ */
+enum PP_AudioFrameSize {
+ PP_AUDIOMINSAMPLEFRAMECOUNT = 64,
+ PP_AUDIOMAXSAMPLEFRAMECOUNT = 32768
+};
+
+
+/**
+ * PP_AudioSampleRate is an enumeration of the different audio sampling rates.
+ * PP_AUDIOSAMPLERATE_44100 is the sample rate used on CDs and
+ * PP_AUDIOSAMPLERATE_48000 is the sample rate used on DVDs and Digital Audio
+ * Tapes.
+ */
+enum PP_AudioSampleRate {
+ PP_AUDIOSAMPLERATE_NONE = 0,
+ PP_AUDIOSAMPLERATE_44100 = 44100,
+ PP_AUDIOSAMPLERATE_48000 = 48000
+} ;
+
+
+/* Interface for configuring audio output */
+interface PPB_AudioConfig_0_5 {
+ /* Create a 16 bit stereo config with the given sample rate. We guarantee
+ * that PP_AUDIOSAMPLERATE_44100 and PP_AUDIOSAMPLERATE_48000 sample rates
+ * are supported. The |sample_frame_count| should be the result of calling
+ * RecommendSampleFrameCount. If the sample frame count or bit rate aren't
+ * supported, this function will fail and return a null resource.
+ *
+ * A single sample frame on a stereo device means one value for the left
+ * channel and one value for the right channel.
+ *
+ * Buffer layout for a stereo int16 configuration:
+ * int16_t* buffer16;
+ * buffer16[0] is the first left channel sample
+ * buffer16[1] is the first right channel sample
+ * buffer16[2] is the second left channel sample
+ * buffer16[3] is the second right channel sample
+ * ...
+ * buffer16[2 * (sample_frame_count - 1)] is the last left channel sample
+ * buffer16[2 * (sample_frame_count - 1) + 1] is the last right channel
+ * sample
+ * Data will always be in the native endian format of the platform.
+ */
+ PP_Resource CreateStereo16Bit(
+ [in] PP_Instance instance,
+ [in] PP_AudioSampleRate sample_rate,
+ [in] uint32_t sample_frame_count);
+
+ /* Returns a supported sample frame count closest to the given requested
+ * count. The sample frame count determines the overall latency of audio.
+ * Since one "frame" is always buffered in advance, smaller frame counts
+ * will yield lower latency, but higher CPU utilization.
+ *
+ * Supported sample frame counts will vary by hardware and system (consider
+ * that the local system might be anywhere from a cell phone or a high-end
+ * audio workstation). Sample counts less than PP_AUDIOMINSAMPLEFRAMECOUNT
+ * and greater than PP_AUDIOMAXSAMPLEFRAMECOUNT are never supported on any
+ * system, but values in between aren't necessarily valid. This function
+ * will return a supported count closest to the requested value.
+ *
+ * If you pass PP_AUDIOSAMPLERATE_NONE as the requested sample count, the
+ * recommended sample for the local system is returned.
+ */
+ uint32_t RecommendSampleFrameCount(
+ [in] PP_AudioSampleRate sample_rate,
+ [in] uint32_t requested_sample_frame_count);
+
+ /* Returns true if the given resource is an AudioConfig object. */
+ PP_Bool IsAudioConfig(
+ [in] PP_Resource resource);
+
+ /* Returns the sample rate for the given AudioConfig resource. If the
+ * resource is invalid, this will return PP_AUDIOSAMPLERATE_NONE.
+ */
+ PP_AudioSampleRate GetSampleRate(
+ [in] PP_Resource config);
+
+ /* Returns the sample frame count for the given AudioConfig resource. If the
+ * resource is invalid, this will return 0. See RecommendSampleFrameCount for
+ * more on sample frame counts.
+ */
+ uint32_t GetSampleFrameCount(
+ [in] PP_Resource config);
+};
diff --git a/ppapi/api/ppb_core.idl b/ppapi/api/ppb_core.idl
new file mode 100644
index 0000000..50ca87a
--- /dev/null
+++ b/ppapi/api/ppb_core.idl
@@ -0,0 +1,69 @@
+/* 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.
+ */
+
+/* Defines the core API. */
+
+/* {PENDING: describe PPB_CORE} */
+interface PPB_Core_0_3 {
+ /* Same as AddRefVar for Resources. */
+ void AddRefResource(
+ [in] PP_Resource resource);
+
+ /* Same as ReleaseVar for Resources. */
+ void ReleaseResource(
+ [in] PP_Resource resource);
+
+ /* Allocate memory.
+ *
+ * Returns NULL If the allocation fails.
+ */
+ mem_t MemAlloc(
+ [in] uint32_t num_bytes);
+
+ /* Free memory; it's safe to pass NULL. */
+ void MemFree(
+ [inout] mem_t ptr);
+
+ /* Returns the "wall clock time" according to the browser.
+ *
+ * See the definition of PP_Time.
+ */
+ PP_Time GetTime();
+
+ /* Returns the "tick time" according to the browser. This clock is used by
+ * the browser when passing some event times to the plugin (e.g., via the
+ * PP_InputEvent::time_stamp_seconds field). It is not correlated to any
+ * actual wall clock time (like GetTime()). Because of this, it will not run
+ * change if the user changes their computer clock.
+ *
+ * TODO(brettw) http://code.google.com/p/chromium/issues/detail?id=57448
+ * This currently does change with wall clock time, but will be fixed in
+ * a future release.
+ */
+ PP_TimeTicks GetTimeTicks();
+
+ /* Schedules work to be executed on the main plugin thread after the
+ * specified delay. The delay may be 0 to specify a call back as soon as
+ * possible.
+ *
+ * The |result| parameter will just be passed as the second argument as the
+ * callback. Many applications won't need this, but it allows a plugin to
+ * emulate calls of some callbacks which do use this value.
+ *
+ * NOTE: If the browser is shutting down or if the plugin has no instances,
+ * then the callback function may not be called.
+ */
+ void CallOnMainThread(
+ [in] int32_t delay_in_milliseconds,
+ [in] PP_CompletionCallback callback,
+ [in] int32_t result);
+
+ /* Returns true if the current thread is the main pepper thread.
+ *
+ * This is useful for implementing sanity checks, and deciding if dispatching
+ * via CallOnMainThread() is required.
+ */
+ PP_Bool IsMainThread();
+};
diff --git a/ppapi/api/ppb_graphics_2d.idl b/ppapi/api/ppb_graphics_2d.idl
new file mode 100644
index 0000000..1a013b1
--- /dev/null
+++ b/ppapi/api/ppb_graphics_2d.idl
@@ -0,0 +1,196 @@
+/* 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.
+ */
+
+/* Defines the PPB_Graphics2D struct. */
+
+/* TODO(neb): Describe PPB_Graphics2D. */
+interface PPB_Graphics2D_0_3 {
+ /* The returned graphics context will not be bound to the plugin instance on
+ * creation (call BindGraphics on the plugin instance to do that).
+ *
+ * Set the is_always_opaque flag if you know that you will be painting only
+ * opaque data to this context. This will disable blending when compositing
+ * the plugin with the web page, which will give slightly higher performance.
+ *
+ * If you set is_always_opaque, your alpha channel should always be set to
+ * 0xFF or there may be painting artifacts. Being opaque will allow the
+ * browser to do a memcpy rather than a blend to paint the plugin, and this
+ * means your alpha values will get set on the page backing store. If these
+ * values are incorrect, it could mess up future blending.
+ *
+ * If you aren't sure, it is always correct to specify that it it not opaque.
+ */
+ PP_Resource Create(
+ [in] PP_Instance instance,
+ [in] PP_Size size,
+ [in] PP_Bool is_always_opaque);
+
+ /* Returns PP_TRUE if the given resource is a valid Graphics2D, PP_FALSE if it
+ * is an invalid resource or is a resource of another type.
+ */
+ PP_Bool IsGraphics2D(
+ [in] PP_Resource resource);
+
+ /* Retrieves the configuration for the given graphics context, filling the
+ * given values (which must not be NULL). On success, returns PP_TRUE. If the
+ * resource is invalid, the output parameters will be set to 0 and it will
+ * return PP_FALSE.
+ */
+ PP_Bool Describe(
+ [in] PP_Resource graphics_2d,
+ [out] PP_Size size,
+ [out] PP_Bool is_always_opqaue);
+
+ /* Enqueues a paint of the given image into the context. THIS HAS NO EFFECT
+ * UNTIL YOU CALL Flush(). As a result, what counts is the contents of the
+ * bitmap when you call Flush, not when you call this function.
+ *
+ * The given image will be placed at |top_left| from the top left of the
+ * context's internal backing store. Then the src_rect will be copied into the
+ * backing store. This parameter may not be NULL.
+ *
+ * The src_rect is specified in the coordinate system of the image being
+ * painted, not the context. For the common case of copying the entire image,
+ * you may specify a NULL |src_rect| pointer. If you are frequently updating
+ * the entire image, consider using ReplaceContents which will give slightly
+ * higher performance.
+ *
+ * The painted area of the source bitmap must fall entirely within the
+ * context. Attempting to paint outside of the context will result in an
+ * error. However, the source bitmap may fall outside the context, as long
+ * as the src_rect subset of it falls entirely within the context.
+ */
+ void PaintImageData(
+ [in] PP_Resource graphics_2d,
+ [in] PP_Resource image_data,
+ [in] PP_Point top_left,
+ [in] PP_Rect src_rect);
+
+ /* Enqueues a scroll of the context's backing store. THIS HAS NO EFFECT UNTIL
+ * YOU CALL Flush(). The data within the given clip rect (you may specify
+ * NULL to scroll the entire region) will be shifted by (dx, dy) pixels.
+ *
+ * This will result in some exposed region which will have undefined
+ * contents. The plugin should call PaintImageData on these exposed regions
+ * to give the correct contents.
+ *
+ * The scroll can be larger than the area of the clip rect, which means the
+ * current image will be scrolled out of the rect. This is not an error but
+ * will be a no-op.
+ */
+ void Scroll(
+ [in] PP_Resource graphics_2d,
+ [in] PP_Rect clip_rect,
+ [in] PP_Point amount);
+
+ /* This function provides a slightly more efficient way to paint the entire
+ * plugin's image. Normally, calling PaintImageData requires that the browser
+ * copy the pixels out of the image and into the graphics context's backing
+ * store. This function replaces the graphics context's backing store with the
+ * given image, avoiding the copy.
+ *
+ * The new image must be the exact same size as this graphics context. If the
+ * new image uses a different image format than the browser's native bitmap
+ * format (use PPB_ImageData.GetNativeImageDataFormat to retrieve this), then
+ * a conversion will be done inside the browser which may slow the performance
+ * a little bit.
+ *
+ * THE NEW IMAGE WILL NOT BE PAINTED UNTIL YOU CALL FLUSH.
+ *
+ * After this call, you should take care to release your references to the
+ * image. If you paint to the image after ReplaceContents, there is the
+ * possibility of significant painting artifacts because the page might use
+ * partially-rendered data when copying out of the backing store.
+ *
+ * In the case of an animation, you will want to allocate a new image for the
+ * next frame. It is best if you wait until the flush callback has executed
+ * before allocating this bitmap. This gives the browser the option of
+ * caching the previous backing store and handing it back to you (assuming
+ * the sizes match). In the optimal case, this means no bitmaps are allocated
+ * during the animation, and the backing store and "front buffer" (which the
+ * plugin is painting into) are just being swapped back and forth.
+ */
+ void ReplaceContents(
+ [in] PP_Resource graphics_2d,
+ [in] PP_Resource image_data);
+
+ /* Flushes any enqueued paint, scroll, and replace commands for the backing
+ * store. This actually executes the updates, and causes a repaint of the
+ * webpage, assuming this graphics context is bound to a plugin instance. This
+ * can run in two modes:
+ *
+ * - In synchronous mode, you specify NULL for the callback and the callback
+ * data. This function will block the calling thread until the image has
+ * been painted to the screen. It is not legal to block the main thread of
+ * the plugin, you can use synchronous mode only from background threads.
+ *
+ * - In asynchronous mode, you specify a callback function and the argument
+ * for that callback function. The callback function will be executed on
+ * the calling thread when the image has been painted to the screen. While
+ * you are waiting for a Flush callback, additional calls to Flush will
+ * fail.
+ *
+ * Because the callback is executed (or thread unblocked) only when the
+ * plugin's current state is actually on the screen, this function provides a
+ * way to rate limit animations. By waiting until the image is on the screen
+ * before painting the next frame, you can ensure you're not generating
+ * updates faster than the screen can be updated.
+ *
+ * <dl>
+ * <dt>Unbound contexts</dt>
+ * <dd>
+ * If the context is not bound to a plugin instance, you will
+ * still get a callback. It will execute after the Flush function returns
+ * to avoid reentrancy. Of course, it will not wait until anything is
+ * painted to the screen because there will be nothing on the screen. The
+ * timing of this callback is not guaranteed and may be deprioritized by
+ * the browser because it is not affecting the user experience.
+ * </dd>
+ *
+ * <dt>Off-screen instances</dt>
+ * <dd>
+ * If the context is bound to an instance that is
+ * currently not visible (for example, scrolled out of view) it will behave
+ * like the "unbound context" case.
+ * </dd>
+ *
+ * <dt>Detaching a context</dt>
+ * <dd>
+ * If you detach a context from a plugin instance, any
+ * pending flush callbacks will be converted into the "unbound context"
+ * case.
+ * </dd>
+ *
+ * <dt>Released contexts</dt>
+ * <dd>
+ * A callback may or may not still get called even if you have released all
+ * of your references to the context. This can occur if there are internal
+ * references to the context that means it has not been internally
+ * destroyed (for example, if it is still bound to an instance) or due to
+ * other implementation details. As a result, you should be careful to
+ * check that flush callbacks are for the context you expect and that
+ * you're capable of handling callbacks for context that you may have
+ * released your reference to.
+ * </dd>
+ *
+ * <dt>Shutdown</dt>
+ * <dd>
+ * If a plugin instance is removed when a Flush is pending, the
+ * callback will not be executed.
+ * </dd>
+ * </dl>
+ *
+ * Returns PP_OK on success, PP_Error_BadResource if the graphics context is
+ * invalid, PP_Error_BadArgument if the callback is null and Flush is being
+ * called from the main thread of the plugin, or PP_Error_InProgress if a
+ * Flush is already pending that has not issued its callback yet. In the
+ * failure case, nothing will be updated and no callback will be scheduled.
+ * TODO(darin): We should ensure that the completion callback always runs, so
+ * that it is easier for consumers to manage memory referenced by a callback.
+ */
+ int32_t Flush(
+ [in] PP_Resource graphics_2d,
+ [in] PP_CompletionCallback callback);
+};
diff --git a/ppapi/api/ppb_image_data.idl b/ppapi/api/ppb_image_data.idl
new file mode 100644
index 0000000..aa3cbd0
--- /dev/null
+++ b/ppapi/api/ppb_image_data.idl
@@ -0,0 +1,86 @@
+/* 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.
+ */
+
+/* Defines the image data API. */
+
+/* Bitmap formats. */
+enum PP_ImageDataFormat {
+ /* 32 bits, BGRA byte order, premultiplied alpha */
+ PP_IMAGEDATAFORMAT_BGRA_PREMUL = 0,
+ /* 32 bits, RGBA byte order, premultiplied alpha */
+ PP_IMAGEDATAFORMAT_RGBA_PREMUL = 1
+};
+
+/* Description of a bitmap. */
+struct PP_ImageDataDesc {
+ /* Byte format. */
+ PP_ImageDataFormat format;
+
+ /* Size of the bitmap in pixels. */
+ PP_Size size;
+
+ /* The row width in bytes. This may be different than width * 4 since there
+ * may be padding at the end of the lines.
+ */
+ int32_t stride;
+};
+
+/* Interface for manipulating 2D bitmaps. */
+interface PPB_ImageData_0_3 {
+ /* Returns the browser's preferred format for image data. This format will be
+ * the format is uses internally for painting. Other formats may require
+ * internal conversions to paint or may have additional restrictions depending
+ * on the function.
+ */
+ PP_ImageDataFormat GetNativeImageDataFormat();
+
+ /* Returns PP_TRUE if the given image data format is supported by the browser.
+ */
+ PP_Bool IsImageDataFormatSupported(
+ [in] PP_ImageDataFormat format);
+
+ /* Allocates an image data resource with the given format and size. The
+ * return value will have a nonzero ID on success, or zero on failure.
+ * Failure means the instance, image size, or format was invalid.
+ *
+ * Set the init_to_zero flag if you want the bitmap initialized to
+ * transparent during the creation process. If this flag is not set, the
+ * current contents of the bitmap will be undefined, and the plugin should
+ * be sure to set all the pixels.
+ *
+ * For security reasons, if uninitialized, the bitmap will not contain random
+ * memory, but may contain data from a previous image produced by the same
+ * plugin if the bitmap was cached and re-used.
+ */
+ PP_Resource Create(
+ [in] PP_Instance instance,
+ [in] PP_ImageDataFormat format,
+ [in] PP_Size size,
+ [in] PP_Bool init_to_zero);
+
+ /* Returns PP_TRUE if the given resource is an image data. Returns PP_FALSE if
+ * the resource is invalid or some type other than an image data.
+ */
+ PP_Bool IsImageData(
+ [in] PP_Resource image_data);
+
+ /* Computes the description of the image data. Returns PP_TRUE on success,
+ * PP_FALSE if the resource is not an image data. On PP_FALSE, the |desc|
+ * structure will be filled with 0.
+ */
+ PP_Bool Describe(
+ [in] PP_Resource image_data,
+ [out] PP_ImageDataDesc desc);
+
+ /* Maps this bitmap into the plugin address space and returns a pointer to the
+ * beginning of the data.
+ */
+ mem_t Map(
+ [in] PP_Resource image_data);
+
+ /* Unmaps this bitmaps from the plugin address space */
+ void Unmap(
+ [in] PP_Resource image_data);
+};
diff --git a/ppapi/api/ppb_instance.idl b/ppapi/api/ppb_instance.idl
new file mode 100644
index 0000000..f237edb
--- /dev/null
+++ b/ppapi/api/ppb_instance.idl
@@ -0,0 +1,55 @@
+/* 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.
+ */
+
+/* This file defines the PPB_Instance interface implemented by the
+ * browser and containing pointers to functions related to
+ * the module instance on a web page.
+ */
+
+/* The PPB_Instance interface contains pointers to functions
+ * related to the module instance on a web page.
+ */
+interface PPB_Instance_0_5 {
+ /* BindGraphics is a pointer to a function that binds the given
+ * graphics as the current drawing surface. The
+ * contents of this device is what will be displayed in the plugin's area
+ * on the web page. The device must be a 2D or a 3D device.
+ *
+ * You can pass a NULL resource as the device parameter to unbind all
+ * devices from the given instance. The instance will then appear
+ * transparent. Re-binding the same device will return PP_TRUE and will do
+ * nothing. Unbinding a device will drop any pending flush callbacks.
+ *
+ * Any previously-bound device will be Release()d. It is an error to bind
+ * a device when it is already bound to another plugin instance. If you want
+ * to move a device between instances, first unbind it from the old one, and
+ * then rebind it to the new one.
+ *
+ * Binding a device will invalidate that portion of the web page to flush the
+ * contents of the new device to the screen.
+ *
+ * Returns PP_Bool containing PP_TRUE if bind was successful or PP_FALSE if
+ * the device was not the correct type. On success, a reference to the
+ * device will be held by the plugin instance, so the caller can release
+ * its reference if it chooses.
+ */
+ PP_Bool BindGraphics(
+ /* A PP_Instance indentifying one instance of a module. */
+ [in] PP_Instance instance,
+ /* A PP_Resourse representing the graphics device. */
+ [in] PP_Resource device);
+
+ /* IsFullFrame is a pointer to a function that determines if the
+ * module instance is full-frame (repr). Such a module represents
+ * the entire document in a frame rather than an embedded resource. This can
+ * happen if the user does a top level navigation or the page specifies an
+ * iframe to a resource with a MIME type registered by the plugin.
+ *
+ * Returns a PP_Bool containing PP_TRUE if the instance is full-frame.
+ */
+ PP_Bool IsFullFrame(
+ /* A PP_Instance indentifying one instance of a module. */
+ [in] PP_Instance instance);
+};
diff --git a/ppapi/api/ppb_url_loader.idl b/ppapi/api/ppb_url_loader.idl
new file mode 100644
index 0000000..6513881
--- /dev/null
+++ b/ppapi/api/ppb_url_loader.idl
@@ -0,0 +1,117 @@
+/* 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.
+ */
+
+/* Defines the URL loader API. */
+
+/* The interface for loading URLs.
+ *
+ * Typical steps for loading an URL:
+ * 1- Create an URLLoader object.
+ * 2- Create an URLRequestInfo object and set properties on it.
+ * 3- Call URLLoader's Open method passing the URLRequestInfo.
+ * 4- When Open completes, call GetResponseInfo to examine the response headers.
+ * 5- Then call ReadResponseBody to stream the data for the response.
+ *
+ * Alternatively, if PP_URLREQUESTPROPERTY_STREAMTOFILE was set on the
+ * URLRequestInfo, then call FinishStreamingToFile at step #5 to wait for the
+ * downloaded file to be complete. The downloaded file may be accessed via the
+ * GetBody method of the URLResponseInfo returned in step #4.
+ */
+interface PPB_URLLoader_0_1 {
+ /* Create a new URLLoader object. Returns 0 if the instance is invalid. The
+ * URLLoader is associated with a particular instance, so that any UI dialogs
+ * that need to be shown to the user can be positioned relative to the window
+ * containing the instance. It is also important for security reasons to
+ * know the origin of the URL request.
+ */
+ PP_Resource Create(
+ [in] PP_Instance instance);
+
+ /* Returns PP_TRUE if the given resource is an URLLoader. Returns PP_FALSE if
+ * the resource is invalid or some type other than an URLLoader.
+ */
+ PP_Bool IsURLLoader(
+ [in] PP_Resource resource);
+
+ /* Begins loading the URLRequestInfo. Completes when response headers are
+ * received or when an error occurs. Use the GetResponseInfo method to
+ * access the response headers.
+ */
+ int32_t Open(
+ [in] PP_Resource loader,
+ [in] PP_Resource request_info,
+ [in] PP_CompletionCallback callback);
+
+ /* If the current URLResponseInfo object corresponds to a redirect, then call
+ * this method to follow the redirect.
+ */
+ int32_t FollowRedirect(
+ [in] PP_Resource loader,
+ [in] PP_CompletionCallback callback);
+
+ /* Returns the current upload progress, which is meaningful after Open has
+ * been called. Progress only refers to the request body and does not include
+ * the headers.
+ *
+ * This data is only available if the URLRequestInfo passed to Open() had the
+ * PP_URLREQUESTPROPERTY_REPORTUPLOADPROGRESS flag set to PP_TRUE.
+ *
+ * This method returns PP_FALSE if upload progress is not available.
+ */
+ PP_Bool GetUploadProgress(
+ [in] PP_Resource loader,
+ [out] int64_t bytes_sent,
+ [out] int64_t total_bytes_to_be_sent);
+
+ /* Returns the current download progress, which is meaningful after Open has
+ * been called. Progress only refers to the response body and does not
+ * include the headers.
+ *
+ * This data is only available if the URLRequestInfo passed to Open() had the
+ * PP_URLREQUESTPROPERTY_REPORTDOWNLOADPROGRESS flag set to PP_TRUE.
+ *
+ * The total bytes to be received may be unknown, in which case
+ * total_bytes_to_be_received will be set to -1. This method returns PP_FALSE
+ * if download progress is not available.
+ */
+ PP_Bool GetDownloadProgress(
+ [in] PP_Resource loader,
+ [out] int64_t bytes_received,
+ [out] int64_t total_bytes_to_be_received);
+
+ /* Returns the current URLResponseInfo object. */
+ PP_Resource GetResponseInfo(
+ [in] PP_Resource loader);
+
+ /* Call this method to read the response body. The size of the buffer must
+ * be large enough to hold the specified number of bytes to read. May
+ * perform a partial read. Returns the number of bytes read or an error
+ * code.
+ */
+ int32_t ReadResponseBody(
+ [in] PP_Resource loader,
+ [out] mem_t buffer,
+ [in] int32_t bytes_to_read,
+ [in] PP_CompletionCallback callback);
+
+ /* If PP_URLREQUESTPROPERTY_STREAMTOFILE was set on the URLRequestInfo passed
+ * to the Open method, then this method may be used to wait for the response
+ * body to be completely downloaded to the file provided by URLResponseInfo's
+ * GetBody method.
+ */
+ int32_t FinishStreamingToFile(
+ [in] PP_Resource loader,
+ [in] PP_CompletionCallback callback);
+
+ /* Cancels any IO that may be pending, and closes the URLLoader object. Any
+ * pending callbacks will still run, reporting PP_ERROR_ABORTED if pending IO
+ * was interrupted. It is NOT valid to call Open again after a call to this
+ * method. Note: If the URLLoader object is destroyed, and it is still open,
+ * then it will be implicitly closed, so you are not required to call the
+ * Close method.
+ */
+ void Close(
+ [in] PP_Resource loader);
+};
diff --git a/ppapi/api/ppb_url_request_info.idl b/ppapi/api/ppb_url_request_info.idl
new file mode 100644
index 0000000..451caa8
--- /dev/null
+++ b/ppapi/api/ppb_url_request_info.idl
@@ -0,0 +1,92 @@
+/* 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.
+ */
+
+/* Defines the URL request info API. */
+
+/* Request properties. */
+enum PP_URLRequestProperty {
+ /* string */
+ PP_URLREQUESTPROPERTY_URL = 0,
+ /* string */
+ PP_URLREQUESTPROPERTY_METHOD = 1,
+ /* string, \n-delim */
+ PP_URLREQUESTPROPERTY_HEADERS = 2,
+ /* PP_Bool (default=PP_FALSE) */
+ PP_URLREQUESTPROPERTY_STREAMTOFILE = 3,
+ /* PP_Bool (default=PP_TRUE) */
+ PP_URLREQUESTPROPERTY_FOLLOWREDIRECTS = 4,
+
+ /* Set to true if you want to be able to poll the download progress via the
+ * URLLoader.GetDownloadProgress function.
+ *
+ * Boolean (default = PP_FALSE).
+ */
+ PP_URLREQUESTPROPERTY_RECORDDOWNLOADPROGRESS = 5,
+
+ /* Set to true if you want to be able to pull the upload progress via the
+ * URLLoader.GetUploadProgress function.
+ *
+ * Boolean (default = PP_FALSE).
+ */
+ PP_URLREQUESTPROPERTY_RECORDUPLOADPROGRESS = 6
+};
+
+/* Interface for making URL requests to URL loader. */
+interface PPB_URLRequestInfo_0_2 {
+ /* Create a new URLRequestInfo object. Returns 0 if the instance is
+ * invalid. */
+ PP_Resource Create(
+ [in] PP_Instance instance);
+
+ /* Returns PP_TRUE if the given resource is an URLRequestInfo. Returns
+ * PP_FALSE if the resource is invalid or some type other than an
+ * URLRequestInfo.
+ */
+ PP_Bool IsURLRequestInfo(
+ [in] PP_Resource resource);
+
+ /* Sets a request property. Returns PP_FALSE if any of the parameters are
+ * invalid, PP_TRUE on success. The value property must be the correct type
+ * according to the property being set.
+ */
+ PP_Bool SetProperty(
+ [in] PP_Resource request,
+ [in] PP_URLRequestProperty property,
+ [in] PP_Var value);
+
+ /* Append data to the request body.
+ *
+ * A Content-Length request header will be automatically generated.
+ *
+ * Returns PP_FALSE if any of the parameters are invalid, PP_TRUE on success.
+ */
+ PP_Bool AppendDataToBody(
+ [in] PP_Resource request,
+ [in] mem_t data,
+ [in] uint32_t len);
+
+ /* Append a file reference to be uploaded.
+ *
+ * A sub-range of the file starting from start_offset may be specified. If
+ * number_of_bytes is -1, then the sub-range to upload extends to the end of
+ * the file.
+ *
+ * An optional (non-zero) last modified time stamp may be provided, which
+ * will be used to validate that the file was not modified since the given
+ * time before it is uploaded. The upload will fail with an error code of
+ * PP_Error_FileChanged if the file has been modified since the given time.
+ * If expected_last_modified_time is 0, then no validation is performed.
+ *
+ * A Content-Length request header will be automatically generated.
+ *
+ * Returns PP_FALSE if any of the parameters are invalid, PP_TRUE on success.
+ */
+ PP_Bool AppendFileToBody(
+ [in] PP_Resource request,
+ [in] PP_Resource file_ref,
+ [in] int64_t start_offset,
+ [in] int64_t number_of_bytes,
+ [in] PP_Time expected_last_modified_time);
+};
diff --git a/ppapi/api/ppb_url_response_info.idl b/ppapi/api/ppb_url_response_info.idl
new file mode 100644
index 0000000..46f8d6a
--- /dev/null
+++ b/ppapi/api/ppb_url_response_info.idl
@@ -0,0 +1,49 @@
+/* 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.
+ */
+
+/* Defines the URL response info API. */
+
+/* Response properties. */
+enum PP_URLResponseProperty{
+ /* string */
+ PP_URLRESPONSEPROPERTY_URL = 0,
+ /* string */
+ PP_URLRESPONSEPROPERTY_REDIRECTURL = 1,
+ /* string */
+ PP_URLRESPONSEPROPERTY_REDIRECTMETHOD = 2,
+ /* int32 */
+ PP_URLRESPONSEPROPERTY_STATUSCODE = 3,
+ /* string */
+ PP_URLRESPONSEPROPERTY_STATUSLINE = 4,
+ /* string, \n-delim */
+ PP_URLRESPONSEPROPERTY_HEADERS = 5
+};
+
+/* Interface for receiving URL responses from the URL loader. */
+interface PPB_URLResponseInfo_0_1 {
+ /* Returns PP_TRUE if the given resource is an URLResponseInfo. Returns
+ * PP_FALSE if the resource is invalid or some type other than an
+ * URLResponseInfo.
+ */
+ PP_Bool IsURLResponseInfo(
+ [in] PP_Resource resource);
+
+ /* Gets a response property. Return PP_VarType_Void if an input parameter is
+ * invalid.
+ */
+ PP_Var GetProperty(
+ [in] PP_Resource response,
+ [in] PP_URLResponseProperty property);
+
+ /* Returns a FileRef pointing to the file containing the response body. This
+ * is only valid if PP_URLREQUESTPROPERTY_STREAMTOFILE was set on the
+ * URLRequestInfo used to produce this response. This file remains valid
+ * until the URLLoader associated with this URLResponseInfo is closed or
+ * destroyed. Returns 0 if PP_URLREQUESTPROPERTY_STREAMTOFILE was not
+ * requested or if the URLLoader has not been opened yet.
+ */
+ PP_Resource GetBodyAsFileRef(
+ [in] PP_Resource response);
+};
diff --git a/ppapi/api/ppb_var.idl b/ppapi/api/ppb_var.idl
new file mode 100644
index 0000000..17a39e2
--- /dev/null
+++ b/ppapi/api/ppb_var.idl
@@ -0,0 +1,69 @@
+/* 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.
+ */
+
+/* This file defines the PPB_Var API. */
+
+/* Defines the PPB_Var struct. */
+interface PPB_Var_0_5 {
+ /* Adds a reference to the given var. If this is not a refcounted object,
+ * this function will do nothing so you can always call it no matter what the
+ * type.
+ */
+ void AddRef(
+ [in] PP_Var var);
+
+ /* Removes a reference to given var, deleting it if the internal refcount
+ * becomes 0. If the given var is not a refcounted object, this function will
+ * do nothing so you can always call it no matter what the type.
+ */
+ void Release(
+ [in] PP_Var var);
+
+ /* Creates a string var from a string. The string must be encoded in valid
+ * UTF-8 and is NOT NULL-terminated, the length must be specified in |len|.
+ * It is an error if the string is not valid UTF-8.
+ *
+ * If the length is 0, the |data| pointer will not be dereferenced and may
+ * be NULL. Note, however, that if you do this, the "NULL-ness" will not be
+ * preserved, as VarToUtf8 will never return NULL on success, even for empty
+ * strings.
+ *
+ * The resulting object will be a refcounted string object. It will be
+ * AddRef()ed for the caller. When the caller is done with it, it should be
+ * Release()d.
+ *
+ * On error (basically out of memory to allocate the string, or input that
+ * is not valid UTF-8), this function will return a Null var.
+ */
+ PP_Var VarFromUtf8(
+ [in] PP_Module module,
+ [in] str_t data,
+ [in] uint32_t len);
+
+ /* Converts a string-type var to a char* encoded in UTF-8. This string is NOT
+ * NULL-terminated. The length will be placed in |*len|. If the string is
+ * valid but empty the return value will be non-NULL, but |*len| will still
+ * be 0.
+ *
+ * If the var is not a string, this function will return NULL and |*len| will
+ * be 0.
+ *
+ * The returned buffer will be valid as long as the underlying var is alive.
+ * If the plugin frees its reference, the string will be freed and the pointer
+ * will be to random memory.
+ */
+ str_t VarToUtf8(
+ [in] PP_Var var,
+ [out] uint32_t len);
+
+ /* Convert a variable to a different type using rules from ECMAScript
+ * specification, section [9].
+ * TODO(neb): Document what happens on failure.
+ */
+ PP_Var ConvertType(
+ [in] PP_Instance instance,
+ [in] PP_Var var,
+ [in] PP_VarType new_type);
+};
diff --git a/ppapi/api/ppp_instance.idl b/ppapi/api/ppp_instance.idl
new file mode 100644
index 0000000..4bc0ef1
--- /dev/null
+++ b/ppapi/api/ppp_instance.idl
@@ -0,0 +1,155 @@
+/* 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.
+ */
+
+/* This file defines the PPP_Instance structure - a series of points to methods
+ * that you must implement in your model.
+ */
+
+/* The PPP_Instance interface contains series of functions that you must
+ * implement in your module. These functions can be trivial (simply return the
+ * default return value) unless you want your module to handle events such as
+ * change of focus or input events (keyboard/mouse) events.
+ */
+interface PPP_Instance_0_4 {
+ /* Function that is called when a new module is instantiated on the web
+ * page. The identifier of the new instance will be passed in as the first
+ * argument (this value is generated by the browser and is an opaque
+ * handle). This is called for each instantiation of the NaCl module, which
+ * is each time the <embed> tag for this module is encountered.
+ *
+ * It's possible for more than one module instance to be created
+ * (i.e. you may get more than one OnCreate without an OnDestroy
+ * in between).
+ *
+ * If this function reports a failure (by returning @a PP_FALSE), the NaCl
+ * module will be deleted and DidDestroy will be called.
+ *
+ * Returns PP_TRUE on success.
+ */
+ PP_Bool DidCreate(
+ /* A PP_Instance indentifying one instance of a module. */
+ [in] PP_Instance instance,
+ /* The number of arguments contained in argn and argv. */
+ [in] uint32_t argc,
+ /* An array of argument names. These argument names are
+ * supplied in the <embed> tag, for example:
+ * <embed id="nacl_module" dimensions="2"> will produce two argument
+ * names: "id" and "dimensions."
+ */
+ [in, size_is(argc)] str_t[] argn,
+ /* An array of argument values. These are the values of the
+ * arguments listed in the <embed> tag, for example
+ * <embed id="nacl_module" dimensions="2"> will produce two argument
+ * values: "nacl_module" and "2." The indices of these values match the
+ * indices of the corresponding names in argn.
+ */
+ [in, size_is(argc)] str_t[] argv);
+
+ /* Function that is called when the module instance is destroyed. This
+ * function will always be called, even if DidCreate returned failure.
+ * The function should deallocate any data associated with the instance.
+ */
+ void DidDestroy(
+ /* A PP_Instance indentifying one instance of a module. */
+ [in] PP_Instance instance);
+
+ /* Function that is called when the position, the size, or the clip
+ * rectangle of the element in the browser that corresponds to this instance
+ * has changed.
+ */
+ void DidChangeView(
+ /* A PP_Instance indentifying the instance whose view changed. */
+ [in] PP_Instance instance,
+ /* The new location on the page of this instance. This is relative to
+ * the top left corner of the viewport, which changes as the
+ * page is scrolled.
+ */
+ [in] PP_Rect position,
+ /* The visible region of the NaCl module. This is relative to the top
+ * left of the plugin's coordinate system (not the page) If the plugin
+ * is invisible, clip will be (0, 0, 0, 0).
+ */
+ [in] PP_Rect clip);
+
+ /* Function to handle when your instance has gained or lost focus. Having
+ * focus means that keyboard events will be sent to the module. An
+ * instance's default condition is that it will not have focus.
+ *
+ * Note: clicks on modules will give focus only if you handle the
+ * click event. Return true from HandleInputEvent to signal that the click
+ * event was handled. Otherwise the browser will bubble the event and give
+ * focus to the element on the page that actually did end up consuming it.
+ * If you're not getting focus, check to make sure you're returning true
+ * from the mouse click in HandleInputEvent.
+ */
+ void DidChangeFocus(
+ /* A PP_Instance indentifying one instance of a module. */
+ [in] PP_Instance instance,
+ /* Indicates whether this NaCl module gained or lost event focus. */
+ [in] PP_Bool has_focus);
+
+ /* Function to handle input events.
+ *
+ * Returns true if the event was handled or false if it was not. If the
+ * event was handled, it will not be forwarded to the web page or browser.
+ * If it was not handled, it will bubble according to the normal rules. So
+ * it is important that a module respond accurately with whether event
+ * propogation should continue.
+ *
+ * Event propogation also controls focus. If you handle an event like a
+ * mouse event, typically your module will be given focus. Returning false
+ * means that the click will be given to a lower part of the page and your
+ * module will not receive focus. This allows a module to be partially
+ * transparent, where clicks on the transparent areas will behave like
+ * clicks to the underlying page.
+ *
+ * Returns PP_TRUE if event was handled, PP_FALSE otherwise.
+ */
+ PP_Bool HandleInputEvent(
+ /* A PP_Instance indentifying one instance of a module. */
+ [in] PP_Instance instance,
+ /* The event. */
+ [in] PP_InputEvent event);
+
+ /* This value represents a pointer to a function that is called after
+ * initialize for a full-frame plugin that was instantiated based on the MIME
+ * type of a DOMWindow navigation. This only applies to modules that are
+ * registered to handle certain MIME types (not current Native Client
+ * modules).
+ *
+ * The given url_loader corresponds to a PPB_URLLoader instance that is
+ * already opened. Its response headers may be queried using
+ * PPB_URLLoader::GetResponseInfo. The url loader is not addrefed on behalf
+ * of the module, if you're going to keep a reference to it, you need to
+ * addref it yourself.
+ *
+ * This method returns PP_FALSE if the module cannot handle the data. In
+ * response to this method, the module should call ReadResponseBody to read
+ * the incoming data.
+ *
+ * Returns PP_TRUE if the data was handled, PP_FALSE otherwise.
+ */
+ PP_Bool HandleDocumentLoad(
+ /* A PP_Instance indentifying one instance of a module. */
+ [in] PP_Instance instance,
+ /* A PP_Resource an open PPB_URLLoader instance. */
+ [in] PP_Resource url_loader);
+
+ /* This value represents a pointer to a function that returns a Var
+ * representing the scriptable object for the given instance. Normally
+ * this will be a PPP_Class object that exposes certain methods the page
+ * may want to call.
+ *
+ * On Failure, the returned var should be a "void" var.
+ *
+ * The returned PP_Var should have a reference added for the caller, which
+ * will be responsible for Release()ing that reference.
+ *
+ * Returns a PP_Var containing scriptable object.
+ */
+ PP_Var GetInstanceObject(
+ /* A PP_Instance indentifying one instance of a module. */
+ [in] PP_Instance instance);
+};
diff --git a/ppapi/api/private/ppb_flash.idl b/ppapi/api/private/ppb_flash.idl
new file mode 100644
index 0000000..55a3862
--- /dev/null
+++ b/ppapi/api/private/ppb_flash.idl
@@ -0,0 +1,60 @@
+/* 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.
+ */
+
+/* This file contains PPB_Flash interface. */
+
+/* PPB_Flash interface. */
+interface PPB_Flash_0_7 {
+ /* Sets or clears the rendering hint that the given plugin instance is always
+ * on top of page content. Somewhat more optimized painting can be used in
+ * this case.
+ */
+ void SetInstanceAlwaysOnTop(
+ [in] PP_Instance instance,
+ [in] PP_Bool on_top);
+
+ PP_Bool DrawGlyphs(
+ [in] PP_Instance instance,
+ [in] PP_Resource pp_image_data,
+ [in] PP_FontDescription_Dev font_desc,
+ [in] uint32_t color,
+ [in] PP_Point position,
+ [in] PP_Rect clip,
+ [in] float_t[3][3] transformation,
+ [in] uint32_t glyph_count,
+ [in, size_is(glyph_count)] uint16_t[] glyph_indices,
+ [in, size_is(glyph_count)] PP_Point[] glyph_advances);
+
+ /* Retrieves the proxy that will be used for the given URL. The result will
+ * be a string in PAC format, or an undefined var on error.
+ */
+ PP_Var GetProxyForURL(
+ [in] PP_Instance instance,
+ [in] str_t url);
+
+ /* Navigate to URL. May open a new tab if target is not "_self". Return true
+ * if success. This differs from javascript:window.open() in that it bypasses
+ * the popup blocker, even when this is not called from an event handler.
+ */
+ PP_Bool NavigateToURL(
+ [in] PP_Instance instance,
+ [in] str_t url,
+ [in] str_t target);
+
+ /* Runs a nested message loop. The plugin will be reentered from this call.
+ * This function is used in places where Flash would normally enter a nested
+ * message loop (e.g., when displaying context menus), but Pepper provides
+ * only an asynchronous call. After performing that asynchronous call, call
+ * |RunMessageLoop()|. In the callback, call |QuitMessageLoop()|.
+ */
+ void RunMessageLoop(
+ [in] PP_Instance instance);
+
+ /* Posts a quit message for the outermost nested message loop. Use this to
+ * exit and return back to the caller after you call RunMessageLoop.
+ */
+ void QuitMessageLoop(
+ [in] PP_Instance instance);
+};
diff --git a/ppapi/api/private/ppb_flash_file.idl b/ppapi/api/private/ppb_flash_file.idl
new file mode 100644
index 0000000..6ad1a8a
--- /dev/null
+++ b/ppapi/api/private/ppb_flash_file.idl
@@ -0,0 +1,81 @@
+/* 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.
+ */
+
+/* This file contains PPB_Flash_File interface. */
+
+/* A directory entry. */
+struct PP_DirEntry_Dev {
+ str_t name;
+ PP_Bool is_dir;
+};
+
+/* Directory. */
+struct PP_DirContents_Dev {
+ int32_t count;
+ [size_is(count)] PP_DirEntry_Dev[] entries;
+};
+
+/* PPB_Flash_File_ModuleLocal */
+interface PPB_Flash_File_ModuleLocal_0_1 {
+ /* Opens a module-local file, returning a file descriptor (posix) or a HANDLE
+ * (win32) into file. Module-local file paths (here and below) are
+ * '/'-separated UTF-8 strings, relative to a module-specific root. The return
+ * value is the ppapi error, PP_OK if success, one of the PP_ERROR_* in case
+ * of failure
+ */
+ int32_t OpenFile(
+ [in] PP_Instance instance,
+ [in] str_t path,
+ [in] int32_t mode,
+ [out] PP_FileHandle file);
+
+ /* Renames a module-local file. The return value is the ppapi error, PP_OK if
+ * success, one of the PP_ERROR_* in case of failure.
+ */
+ int32_t RenameFile(
+ [in] PP_Instance instance,
+ [in] str_t path_from,
+ [in] str_t path_to);
+
+ /* Deletes a module-local file or directory. If recursive is set and the path
+ * points to a directory, deletes all the contents of the directory. The
+ * return value is the ppapi error, PP_OK if success, one of the PP_ERROR_* in
+ * case of failure.
+ */
+ int32_t DeleteFileOrDir(
+ [in] PP_Instance instance,
+ [in] str_t path,
+ [in] PP_Bool recursive);
+
+ /* Creates a module-local directory. The return value is the ppapi error,
+ * PP_OK if success, one of the PP_ERROR_* in case of failure.
+ */
+ int32_t CreateDir(
+ [in] PP_Instance instance,
+ [in] str_t path);
+
+ /* Queries information about a module-local file. The return value is the
+ * ppapi error, PP_OK if success, one of the PP_ERROR_* in case of failure.
+ */
+ int32_t QueryFile(
+ [in] PP_Instance instance,
+ [in] str_t path,
+ [out] PP_FileInfo_Dev info);
+
+ /* Gets the list of files contained in a module-local directory. The return
+ * value is the ppapi error, PP_OK if success, one of the PP_ERROR_* in case
+ * of failure. If non-NULL, the returned contents should be freed with
+ * FreeDirContents.
+ */
+ int32_t GetDirContents(
+ [in] PP_Instance instance,
+ [in] str_t path,
+ [out] PP_DirContents_Dev contents);
+
+ /* Frees the data allocated by GetDirContents. */
+ void FreeDirContents(
+ [in] PP_Instance instance,
+ [in] PP_DirContents_Dev contents);
+};
diff --git a/ppapi/api/private/ppb_flash_menu.idl b/ppapi/api/private/ppb_flash_menu.idl
new file mode 100644
index 0000000..df6aa44
--- /dev/null
+++ b/ppapi/api/private/ppb_flash_menu.idl
@@ -0,0 +1,52 @@
+/* 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.
+ */
+
+/* PPB_Flash */
+
+/* Menu item type.
+ *
+ * TODO(viettrungluu): Radio items not supported yet. Will also probably want
+ * special menu items tied to clipboard access.
+ */
+enum PP_Flash_MenuItem_Type {
+ PP_FLASH_MENUITEM_TYPE_NORMAL = 0,
+ PP_FLASH_MENUITEM_TYPE_CHECKBOX = 1,
+ PP_FLASH_MENUITEM_TYPE_SEPARATOR = 2,
+ PP_FLASH_MENUITEM_TYPE_SUBMENU = 3
+};
+
+struct PP_Flash_MenuItem {
+ PP_Flash_MenuItem_Type type;
+ str_t name;
+ int32_t id;
+ PP_Bool enabled;
+ PP_Bool checked;
+ PP_Flash_Menu submenu;
+};
+
+struct PP_Flash_Menu {
+ uint32_t count;
+ [size_is(count)] PP_Flash_MenuItem[] items;
+};
+
+interface PPB_Flash_Menu_0_1 {
+ PP_Resource Create(
+ [in] PP_Instance instance_id,
+ [in] PP_Flash_Menu menu_data);
+
+ PP_Bool IsFlashMenu(
+ [in] PP_Resource resource_id);
+
+ /* Display a context menu at the given location. If the user selects an item,
+ * |selected_id| will be set to its |id| and the callback called with |PP_OK|.
+ * If the user dismisses the menu without selecting an item,
+ * |PP_ERROR_USERCANCEL| will be indicated.
+ */
+ int32_t Show(
+ [in] PP_Resource menu_id,
+ [in] PP_Point location,
+ [out] int32_t selected_id,
+ [in] PP_CompletionCallback callback);
+};
diff --git a/ppapi/api/private/ppb_flash_net_connector.idl b/ppapi/api/private/ppb_flash_net_connector.idl
new file mode 100644
index 0000000..3886dad
--- /dev/null
+++ b/ppapi/api/private/ppb_flash_net_connector.idl
@@ -0,0 +1,41 @@
+/* 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.
+ */
+
+/* This is an opaque type holding a network address. */
+struct PP_Flash_NetAddress {
+ uint32_t size;
+ [fixed=128] uint8_t data;
+};
+
+interface PPB_Flash_NetConnector_0_1 {
+ PP_Resource Create(
+ [in] PP_Instance instance_id);
+ PP_Bool IsFlashNetConnector(
+ [in] PP_Resource resource_id);
+
+ /* Connect to a TCP port given as a host-port pair. The local and remote
+ * addresses of the connection (if successful) are returned in
+ * |local_addr_out| and |remote_addr_out|, respectively, if non-null.
+ */
+ int32_t ConnectTcp(
+ [in] PP_Resource connector_id,
+ [in] str_t host,
+ [in] uint16_t port,
+ [out] PP_FileHandle socket_out,
+ [out] PP_Flash_NetAddress local_addr_out,
+ [out] PP_Flash_NetAddress remote_addr_out,
+ [in] PP_CompletionCallback callback);
+
+ /* Same as |ConnectTcp()|, but connecting to the address given by |addr|. A
+ * typical use-case would be for reconnections.
+ */
+ int32_t ConnectTcpAddress(
+ [in] PP_Resource connector_id,
+ [in] PP_Flash_NetAddress addr,
+ [out] PP_FileHandle socket_out,
+ [out] PP_Flash_NetAddress local_addr_out,
+ [out] PP_Flash_NetAddress remote_addr_out,
+ [in] PP_CompletionCallback callback);
+};
diff --git a/ppapi/api/private/ppb_nacl_private.idl b/ppapi/api/private/ppb_nacl_private.idl
new file mode 100644
index 0000000..fc31dbb
--- /dev/null
+++ b/ppapi/api/private/ppb_nacl_private.idl
@@ -0,0 +1,28 @@
+/* Copyright (c) 2010 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.
+ */
+
+/* This file contains NaCl private interfaces. */
+
+/* PPB_NaCl_Private */
+interface PPB_NaCl_Private_0_1 {
+ /* This function launches NaCl's sel_ldr process. On success, the function
+ * returns true, otherwise it returns false. When it returns true, it will
+ * write |socket_count| nacl::Handles to imc_handles and will write the
+ * nacl::Handle of the created process to |nacl_process_handle|. Finally,
+ * the function will write the process ID of the created process to
+ * |nacl_process_id|.
+ */
+ bool LaunchSelLdr(
+ [in] str_t alleged_url,
+ [in] int32_t socket_count,
+ [out] mem_t imc_handles,
+ [out] mem_t nacl_process_handle,
+ [out] int32_t nacl_process_id);
+
+ /* On POSIX systems, this function returns the file descriptor of
+ * /dev/urandom. On non-POSIX systems, this function returns 0.
+ */
+ int32_t UrandomFD();
+};
diff --git a/ppapi/api/private/ppb_pdf.idl b/ppapi/api/private/ppb_pdf.idl
new file mode 100644
index 0000000..3a6094f
--- /dev/null
+++ b/ppapi/api/private/ppb_pdf.idl
@@ -0,0 +1,141 @@
+/* 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.
+ */
+
+/* This file contains PPB_PDF interface. */
+
+enum PP_ResourceString{
+ PP_RESOURCESTRING_PDFGETPASSWORD = 0,
+ PP_RESOURCESTRING_PDFLOADING = 1,
+ PP_RESOURCESTRING_PDFLOAD_FAILED = 2
+};
+
+enum PP_ResourceImage{
+ PP_RESOURCEIMAGE_PDF_BUTTON_FTH = 0,
+ PP_RESOURCEIMAGE_PDF_BUTTON_FTH_HOVER = 1,
+ PP_RESOURCEIMAGE_PDF_BUTTON_FTH_PRESSED = 2,
+ PP_RESOURCEIMAGE_PDF_BUTTON_FTW = 3,
+ PP_RESOURCEIMAGE_PDF_BUTTON_FTW_HOVER = 4,
+ PP_RESOURCEIMAGE_PDF_BUTTON_FTW_PRESSED = 5,
+ PP_RESOURCEIMAGE_PDF_BUTTON_ZOOMIN = 6,
+ PP_RESOURCEIMAGE_PDF_BUTTON_ZOOMIN_HOVER = 7,
+ PP_RESOURCEIMAGE_PDF_BUTTON_ZOOMIN_PRESSED = 8,
+ PP_RESOURCEIMAGE_PDF_BUTTON_ZOOMOUT = 9,
+ PP_RESOURCEIMAGE_PDF_BUTTON_ZOOMOUT_HOVER = 10,
+ PP_RESOURCEIMAGE_PDF_BUTTON_ZOOMOUT_PRESSED = 11,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_0 = 12,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_1 = 13,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_2 = 14,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_3 = 15,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_4 = 16,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_5 = 17,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_6 = 18,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_7 = 19,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_8 = 20,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_9 = 21,
+ PP_RESOURCEIMAGE_PDF_BUTTON_THUMBNAIL_NUM_BACKGROUND = 22
+};
+
+enum PP_PrivateFontCharset {
+ PP_PRIVATEFONTCHARSET_ANSI = 0,
+ PP_PRIVATEFONTCHARSET_DEFAULT = 1,
+ PP_PRIVATEFONTCHARSET_SYMBOL = 2,
+ PP_PRIVATEFONTCHARSET_MAC = 77,
+ PP_PRIVATEFONTCHARSET_SHIFTJIS = 128,
+ PP_PRIVATEFONTCHARSET_HANGUL = 129,
+ PP_PRIVATEFONTCHARSET_JOHAB = 130,
+ PP_PRIVATEFONTCHARSET_GB2312 = 134,
+ PP_PRIVATEFONTCHARSET_CHINESEBIG5 = 136,
+ PP_PRIVATEFONTCHARSET_GREEK = 161,
+ PP_PRIVATEFONTCHARSET_TURKISH = 162,
+ PP_PRIVATEFONTCHARSET_VIETNAMESE = 163,
+ PP_PRIVATEFONTCHARSET_HEBREW = 177,
+ PP_PRIVATEFONTCHARSET_ARABIC = 178,
+ PP_PRIVATEFONTCHARSET_BALTIC = 186,
+ PP_PRIVATEFONTCHARSET_RUSSIAN = 204,
+ PP_PRIVATEFONTCHARSET_THAI = 222,
+ PP_PRIVATEFONTCHARSET_EASTEUROPE = 238,
+ PP_PRIVATEFONTCHARSET_OEM = 255
+};
+
+struct PP_PrivateFontFileDescription {
+ str_t face;
+ uint32_t weight;
+ PP_Bool italic;
+};
+
+struct PP_PrivateFindResult {
+ int32_t start_index;
+ int32_t length;
+};
+
+interface PPB_PDF_0_1 {
+ /* Returns a localized string. */
+ PP_Var GetLocalizedString(
+ [in] PP_Instance instance,
+ [in] PP_ResourceString string_id);
+
+ /* Returns a resource image. */
+ PP_Resource GetResourceImage(
+ [in] PP_Instance instance,
+ [in] PP_ResourceImage image_id);
+
+ /* Returns a resource identifying a font file corresponding to the given font
+ * request after applying the browser-specific fallback.
+ *
+ * Currently Linux-only.
+ */
+ PP_Resource GetFontFileWithFallback(
+ [in] PP_Instance instance,
+ [in] PP_FontDescription_Dev description,
+ [in] PP_PrivateFontCharset charset);
+
+ /* Given a resource previously returned by GetFontFileWithFallback, returns
+ * a pointer to the requested font table. Linux only.
+ */
+ PP_Bool GetFontTableForPrivateFontFile(
+ [in] PP_Resource font_file,
+ [in] uint32_t table,
+ [out] mem_t output,
+ [out] uint32_t output_length);
+
+ /* Search the given string using ICU. Use PPB_Core's MemFree on results when
+ * done.
+ */
+ void SearchString(
+ [in] PP_Instance instance,
+ [in] mem_t string,
+ [in] mem_t term,
+ [in] PP_Bool case_sensitive,
+ [out, size_is(count)] PP_PrivateFindResult[] results,
+ [out] int32_t count);
+
+ /* Since WebFrame doesn't know about PPAPI requests, it'll think the page has
+ * finished loading even if there are outstanding requests by the plugin.
+ * Take this out once WebFrame knows about requests by PPAPI plugins.
+ */
+ void DidStartLoading(
+ [in] PP_Instance instance);
+ void DidStopLoading(
+ [in] PP_Instance instance);
+
+ /* Sets content restriction for a full-page plugin (i.e. can't copy/print).
+ * The value is a bitfield of ContentRestriction enums.
+ */
+ void SetContentRestriction(
+ [in] PP_Instance instance,
+ [in] int32_t restrictions);
+
+ /* Use UMA so we know average pdf page count. */
+ void HistogramPDFPageCount(
+ [in] int32_t count);
+
+ /* Notifies the browser that the given action has been performed. */
+ void UserMetricsRecordAction(
+ [in] PP_Var action);
+
+ /* Notifies the browser that the PDF has an unsupported feature. */
+ void HasUnsupportedFeature(
+ [in] PP_Instance instance);
+};
diff --git a/ppapi/api/private/ppb_proxy_private.idl b/ppapi/api/private/ppb_proxy_private.idl
new file mode 100644
index 0000000..b455636
--- /dev/null
+++ b/ppapi/api/private/ppb_proxy_private.idl
@@ -0,0 +1,17 @@
+/* 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.
+ */
+
+/* Exposes functions needed by the out-of-process proxy to call into the
+ * renderer PPAPI implementation.
+ */
+interface PPB_Proxy_Private_0_2 {
+ /* Called when the given plugin process has crashed. */
+ void PluginCrashed(
+ [in] PP_Module module);
+
+ /* Returns the instance for the given resource, or 0 on failure. */
+ PP_Instance GetInstanceForResource(
+ [in] PP_Resource resource);
+};
diff --git a/ppapi/api/trusted/ppb_audio_trusted.idl b/ppapi/api/trusted/ppb_audio_trusted.idl
new file mode 100644
index 0000000..775ef15
--- /dev/null
+++ b/ppapi/api/trusted/ppb_audio_trusted.idl
@@ -0,0 +1,43 @@
+/* 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.
+ */
+
+/* This file defines the trusted audio interface. */
+
+/* This interface is to be used by proxy implementations. All
+ * functions should be called from the main thread only. The
+ * resource returned is an Audio resource; most of the PPB_Audio
+ * interface is also usable on this resource.
+ */
+[mainthread] interface PPB_AudioTrusted_0_5 {
+ /* Returns an audio resource. */
+ PP_Resource CreateTrusted(
+ [in] PP_Instance instance);
+
+ /* Opens a paused audio interface, used by trusted side of proxy.
+ * Returns PP_ERROR_WOULD_BLOCK on success, and invokes
+ * the |create_callback| asynchronously to complete.
+ * As this function should always be invoked from the main thread,
+ * do not use the blocking variant of PP_CompletionCallback.
+ */
+ int32_t Open(
+ [in] PP_Resource audio,
+ [in] PP_Resource config,
+ [in] PP_CompletionCallback create_callback);
+
+ /* Get the sync socket. Use once Open has completed.
+ * Returns PP_OK on success.
+ */
+ int32_t GetSyncSocket(
+ [in] PP_Resource audio,
+ [out] handle_t sync_socket);
+
+ /* Get the shared memory interface. Use once Open has completed.
+ * Returns PP_OK on success.
+ */
+ int32_t GetSharedMemory(
+ [in] PP_Resource audio,
+ [out] handle_t shm_handle,
+ [out] uint32_t shm_size);
+};
diff --git a/ppapi/api/trusted/ppb_image_data_trusted.idl b/ppapi/api/trusted/ppb_image_data_trusted.idl
new file mode 100644
index 0000000..d9339c4
--- /dev/null
+++ b/ppapi/api/trusted/ppb_image_data_trusted.idl
@@ -0,0 +1,20 @@
+/* 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.
+ */
+
+/* This file defines the trusted ImageData interface. */
+
+/* Trusted interface */
+interface PPB_ImageDataTrusted_0_4 {
+ /* Returns the internal shared memory pointer associated with the given
+ * ImageData resource. Used for proxying. Returns PP_OK on success, or
+ * PP_ERROR_* on failure. On success, the size in bytes of the shared
+ * memory region will be placed into |*byte_count|, and the handle for
+ * the shared memory in |*handle|.
+ */
+ int32_t GetSharedMemory(
+ [in] PP_Resource image_data,
+ [out] handle_t handle,
+ [out] uint32_t byte_count);
+};
diff --git a/ppapi/api/trusted/ppb_url_loader_trusted.idl b/ppapi/api/trusted/ppb_url_loader_trusted.idl
new file mode 100644
index 0000000..1deafa8
--- /dev/null
+++ b/ppapi/api/trusted/ppb_url_loader_trusted.idl
@@ -0,0 +1,40 @@
+/* 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.
+ */
+
+/* URL loader trusted interfaces. */
+
+/* Callback that indicates the status of the download and upload for the
+ * given URLLoader resource.
+ */
+typedef void PP_URLLoaderTrusted_StatusCallback(
+ PP_Instance pp_instance,
+ PP_Resource pp_resource,
+ int64_t bytes_sent,
+ int64_t total_bytes_to_be_sent,
+ int64_t bytes_received,
+ int64_t total_bytes_to_be_received);
+
+/* Available only to trusted implementations. */
+interface PPB_URLLoaderTrusted_0_3 {
+ /* Grant this URLLoader the capability to make unrestricted cross-origin
+ * requests. */
+ void GrantUniversalAccess(PP_Resource loader);
+
+ /* Registers that the given function will be called when the upload or
+ * downloaded byte count has changed. This is not exposed on the untrusted
+ * interface because it can be quite chatty and encourages people to write
+ * feedback UIs that update as frequently as the progress updates.
+ *
+ * The other serious gotcha with this callback is that the callback must not
+ * mutate the URL loader or cause it to be destroyed.
+ *
+ * However, the proxy layer needs this information to push to the other
+ * process, so we expose it here. Only one callback can be set per URL
+ * Loader. Setting to a NULL callback will disable it.
+ */
+ void RegisterStatusCallback(
+ [in] PP_Resource loader,
+ [in] PP_URLLoaderTrusted_StatusCallback cb);
+};
--
cgit v1.1