Home | History | Annotate | Download | only in private
      1 /* Copyright 2013 The Chromium Authors. All rights reserved.
      2  * Use of this source code is governed by a BSD-style license that can be
      3  * found in the LICENSE file.
      4  */
      5 
      6 /**
      7  * This file contains interface functions used for unit testing. Do not use in
      8  * production code. They are not guaranteed to be available in normal plugin
      9  * environments so you should not depend on them.
     10  */
     11 
     12 label Chrome {
     13   M33 = 1.0
     14 };
     15 
     16 interface PPB_Testing_Private {
     17   /**
     18    * Reads the bitmap data out of the backing store for the given
     19    * DeviceContext2D and into the given image. If the data was successfully
     20    * read, it will return PP_TRUE.
     21    *
     22    * This function should not generally be necessary for normal plugin
     23    * operation. If you want to update portions of a device, the expectation is
     24    * that you will either regenerate the data, or maintain a backing store
     25    * pushing updates to the device from your backing store via PaintImageData.
     26    * Using this function will introduce an extra copy which will make your
     27    * plugin slower. In some cases, this may be a very expensive operation (it
     28    * may require slow cross-process transitions or graphics card readbacks).
     29    *
     30    * Data will be read into the image starting at |top_left| in the device
     31    * context, and proceeding down and to the right for as many pixels as the
     32    * image is large. If any part of the image bound would fall outside of the
     33    * backing store of the device if positioned at |top_left|, this function
     34    * will fail and return PP_FALSE.
     35    *
     36    * The image format must be of the format
     37    * PPB_ImageData.GetNativeImageDataFormat() or this function will fail and
     38    * return PP_FALSE.
     39    *
     40    * The returned image data will represent the current status of the backing
     41    * store. This will not include any paint, scroll, or replace operations
     42    * that have not yet been flushed; these operations are only reflected in
     43    * the backing store (and hence ReadImageData) until after a Flush()
     44    * operation has completed.
     45    */
     46   PP_Bool ReadImageData([in] PP_Resource device_context_2d,
     47                         [in] PP_Resource image,
     48                         [in] PP_Point top_left);
     49 
     50   /**
     51    * Runs a nested message loop. The plugin will be reentered from this call.
     52    * This function is used for unit testing the API. The normal pattern is to
     53    * issue some asynchronous call that has a callback. Then you call
     54    * RunMessageLoop which will suspend the plugin and go back to processing
     55    * messages, giving the asynchronous operation time to complete. In your
     56    * callback, you save the data and call QuitMessageLoop, which will then
     57    * pop back up and continue with the test. This avoids having to write a
     58    * complicated state machine for simple tests for asynchronous APIs.
     59    */
     60   void RunMessageLoop([in] PP_Instance instance);
     61 
     62   /**
     63    * Posts a quit message for the outermost nested message loop. Use this to
     64    * exit and return back to the caller after you call RunMessageLoop.
     65    */
     66   void QuitMessageLoop([in] PP_Instance instance);
     67 
     68   /**
     69    * Returns the number of live objects (resources + strings + objects)
     70    * associated with this plugin instance. Used for detecting leaks. Returns
     71    * (uint32_t)-1 on failure.
     72    */
     73   uint32_t GetLiveObjectsForInstance([in] PP_Instance instance);
     74 
     75   /**
     76    * Returns PP_TRUE if the plugin is running out-of-process, PP_FALSE
     77    * otherwise.
     78    */
     79   PP_Bool IsOutOfProcess();
     80 
     81   /**
     82    * Passes the input event to the browser, which sends it back to the
     83    * plugin. The plugin should implement PPP_InputEvent and register for
     84    * the input event type.
     85    *
     86    * This method sends an input event through the browser just as if it had
     87    * come from the user. If the browser determines that it is an event for the
     88    * plugin, it will be sent to be handled by the plugin's PPP_InputEvent
     89    * interface. When generating mouse events, make sure the position is within
     90    * the plugin's area on the page. When generating a keyboard event, make sure
     91    * the plugin is focused.
     92    *
     93    * Note that the browser may generate extra input events in order to
     94    * maintain certain invariants, such as always having a "mouse enter" event
     95    * before any other mouse event. Furthermore, the event the plugin receives
     96    * after sending a simulated event will be slightly different from the
     97    * original event. The browser may change the timestamp, add modifiers, and
     98    * slightly alter the mouse position, due to coordinate transforms it
     99    * performs.
    100    */
    101   void SimulateInputEvent([in] PP_Instance instance,
    102                           [in] PP_Resource input_event);
    103 
    104   /**
    105    * Returns the URL for the document. This is a safe way to retrieve
    106    * window.location.href.
    107    * If the canonicalized URL is valid, the method will parse the URL
    108    * and fill in the components structure. This pointer may be NULL
    109    * to specify that no component information is necessary.
    110    */
    111   PP_Var GetDocumentURL([in] PP_Instance instance,
    112                         [out] PP_URLComponents_Dev components);
    113 
    114   /**
    115    * Fetches up to |array_size| active PP_Vars in the tracker. Returns the
    116    * number of vars in the tracker. The active vars are written to |live_vars|
    117    * contiguously starting at index 0. The vars are not in any particular order.
    118    * If the number of live vars is greater than |array_size|, then an arbitrary
    119    * subset of |array_size| vars is written to |live_vars|. The reference count
    120    * of the returned PP_Vars will *not* be affected by this call.
    121    */
    122   uint32_t GetLiveVars([size_as=array_size] PP_Var[] live_vars,
    123                        [in] uint32_t array_size);
    124 
    125   /**
    126    * Sets the threshold size at which point we switch from transmitting
    127    * array buffers in IPC messages to using shared memory. This is only used
    128    * for testing purposes where we need to transmit small buffers using shmem
    129    * (in order to have fast tests). Passing a value of 0 resets the threshold
    130    * to its default. The threshold is in bytes.
    131    */
    132   void SetMinimumArrayBufferSizeForShmem([in] PP_Instance instance,
    133                                          [in] uint32_t threshold);
    134 };
    135