path: root/chrome/common/chrome_plugin_api.h

// Copyright (c) 2009 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 header specifies the Chrome Plugin API.  It is based heavily on NPAPI.
// The key difference is that Chrome plugins can be loaded for the lifetime
// of the browser, and are not tied to a specific web page.
//
// NOTE: This API is not final and may change or go away at any point.
//
// All strings in the API are UTF8-encoded unless otherwise noted.

#ifndef CHROME_COMMON_CHROME_PLUGIN_API_H__
#define CHROME_COMMON_CHROME_PLUGIN_API_H__

#include "base/basictypes.h"

#ifndef STDCALL
#ifdef WIN32
#define STDCALL __stdcall
#else
#define STDCALL
#endif // WIN32
#endif // STDCALL

#ifdef __cplusplus
extern "C" {
#endif

// The current version of the API, used by the 'version' field of CPPluginFuncs
// and CPBrowserFuncs.
#define CP_MAJOR_VERSION 0
#define CP_MINOR_VERSION 11
#define CP_VERSION       ((CP_MAJOR_VERSION << 8) | (CP_MINOR_VERSION))

#define CP_GET_MAJOR_VERSION(version) ((version & 0xff00) >> 8)
#define CP_GET_MINOR_VERSION(version) (version & 0x00ff)

typedef unsigned char CPBool;

// Chrome plugins can be loaded into different process types.
typedef enum {
  CP_PROCESS_BROWSER = 0,
  CP_PROCESS_PLUGIN,
  CP_PROCESS_RENDERER,
} CPProcessType;

// Return codes.  Error values are negative.
typedef enum {
  // No error
  CPERR_SUCCESS = 0,

  // (network) An asynchronous IO operation is not complete
  CPERR_IO_PENDING = -1,

  // Generic failure
  CPERR_FAILURE = -2,

  // The API versions used by plugin and host are incompatible
  CPERR_INVALID_VERSION = -3,

  // The operation was cancelled
  CPERR_CANCELLED = -4,

  // An invalid parameter was passed
  CPERR_INVALID_PARAMETER = -5,
} CPError;

// Types of response info metadata to query using CPP_GetResponseInfo.
typedef enum {
  // HTTP status code.
  CPRESPONSEINFO_HTTP_STATUS = 0,

  // Raw headers from the server, including the status line.  Headers should
  // be delimited by "\0", and end with "\0\0" (a blank line).
  CPRESPONSEINFO_HTTP_RAW_HEADERS = 1,
} CPResponseInfoType;

// An identifier for the plugin used by the browser.
typedef struct _CPID_t {
  int unused;
} CPID_t;
typedef struct _CPID_t* CPID;

// An identifier that encapsulates the browsing context needed by various APIs.
// This includes information about what tab a request was made from, and what
// profile is active.  Note that this ID is global to all processes, so it can
// be passed from one process to another.  The value 0 is reserved for an
// undefined context.
typedef uint32 CPBrowsingContext;

// Types of context info to query using CPB_GetBrowsingContextInfo.
typedef enum {
  // The data directory for the profile associated with this context as a
  // pointer to a null-terminated string.  The plugin can save persistent data
  // to this directory.  The returned pointer should be freed using CPB_Free.
  CPBROWSINGCONTEXT_DATA_DIR_PTR = 0,

  // The locale language code used for the browser UI.  The returned pointer
  // should be freed using CPB_Free.
  CPBROWSINGCONTEXT_UI_LOCALE_PTR = 1,
} CPBrowsingContextInfoType;

// A network request object.
typedef struct _CPRequest {
  void* pdata;  // plugin private data
  const char* url;  // the URL being requested
  const char* method;  // the request method as an uppercase string (ex: "GET")
  CPBrowsingContext context;  // context in which this request was made
} CPRequest;

typedef enum {
  CPREQUESTLOAD_NORMAL = 0,

  // This is "normal reload", meaning an if-none-match/if-modified-since query
  CPREQUESTLOAD_VALIDATE_CACHE = 1 << 0,

  // This is "shift-reload", meaning a "pragma: no-cache" end-to-end fetch
  CPREQUESTLOAD_BYPASS_CACHE = 1 << 1,

  // This is a back/forward style navigation where the cached content should
  // be preferred over any protocol specific cache validation.
  CPREQUESTLOAD_PREFERRING_CACHE = 1 << 2,

  // This is a navigation that will fail if it cannot serve the requested
  // resource from the cache (or some equivalent local store).
  CPREQUESTLOAD_ONLY_FROM_CACHE = 1 << 3,

  // This is a navigation that will not use the cache at all.  It does not
  // impact the HTTP request headers.
  CPREQUESTLOAD_DISABLE_CACHE = 1 << 4,

  // This navigation should not be intercepted by plugins.
  CPREQUESTLOAD_DISABLE_INTERCEPT = 1 << 5,

  // This request should be loaded synchronously.  What this means is that
  // CPR_StartRequest and CPR_Read will never return CPERR_IO_PENDING - they
  // will block until a response is available, and return success or failure.
  CPREQUESTLOAD_SYNCHRONOUS = 1 << 20,
} CPRequestLoadFlags;

//
// Functions provided by plugin to host.
//

// Called when the browser is unloading the plugin.
typedef CPError (STDCALL *CPP_ShutdownFunc)(void);

// Returns true if the plugin is interested in handling this request.
typedef CPBool (STDCALL *CPP_ShouldInterceptRequestFunc)(CPRequest* request);

// Called when an HTML dialog was closed.  json_retval is the JSON string
// containing the return value sent back by the dialog (using Chrome's
// JavaScript DOM bindings).
typedef void (STDCALL *CPP_HtmlDialogClosedFunc)(
    void* plugin_context, const char* json_retval);

// Asks the plugin to handle the given command.  'command_data' is command-
// specific data used for some builtin commands: see gears_api.h for
// possible types.  It is only valid for the duration of this call.
typedef CPError (STDCALL *CPP_HandleCommandFunc)(
    CPBrowsingContext context, int command, void* command_data);

//
// Functions provided by host to plugin.
//

// Asks the host to handle the given command.  'command_data' is
// command-specific data used for some builtin commands: see gears_api.h for
// possible types.  It is only valid for the duration of this call.
typedef CPError (STDCALL *CPB_HandleCommandFunc)(
    CPID id, CPBrowsingContext context, int command, void* command_data);

// Asks the browser to enable/disable request interception for this plugin for
// the given schemes.  'schemes' is an array of strings containing the scheme
// names the plugin wishes to handle; case is ignored.  If 'schemes' is NULL or
// empty, request interception is disabled for this plugin.  Multiple calls to
// this function will add to the existing set of enabled schemes. The browser
// should call the plugin's CPP_ShouldInterceptRequestFunc for any network
// requests it makes that match a given scheme.  The browser may choose not to
// allow the plugin to intercept certain protocols.
typedef void (STDCALL *CPB_EnableRequestInterceptFunc)(
    CPID id, const char** schemes, uint32 num_schemes);

// Asks the browser to create a request object for the given method/url.
// Returns CPERR_SUCCESS and puts the new object into the 'request' field on
// success, or an error code on failure.  The plugin must call CPR_EndRequest
// to clean up the request object when it is done with it.
typedef CPError (STDCALL *CPB_CreateRequestFunc)(
    CPID id, CPBrowsingContext context, const char* method, const char* url,
    CPRequest** request);

// Queries the browser's cookie store for cookies set for the given URL.
// Sets 'cookies' to an allocated string containing the cookies as
// semicolon-delimited "name=value" pairs on success, NULL on failure.
// The memory should be freed using CPB_Free when done.
typedef CPError (STDCALL *CPB_GetCookiesFunc)(
    CPID id, CPBrowsingContext context, const char* url, char** cookies);

// Allocates memory for the given size using the browser's allocator.  Call
// CPB_Free when done.
typedef void* (STDCALL *CPB_AllocFunc)(uint32 size);

// Frees a pointer allocated by CPB_Alloc.
typedef void (STDCALL *CPB_FreeFunc)(void* memory);


// Sets a flag that influences when the plugin process created to host
// the plugin is shutdown. Generally, the plugin process is terminated
// when no more plugin instances exist, this is the default behavior.
// If keep_alive is non-zero, the process will not be terminated when
// the instance count goes to zero. Note: a non-zero keep_alive value
// does not prevent the plugin process from being terminated upon
// overall browser shutdown.
typedef void (STDCALL *CPB_SetKeepProcessAliveFunc)(CPID id,
                                                    CPBool keep_alive);

// Asks the browser to show an HTML dialog to the user.  The dialog contents
// should be loaded from the given URL.  The 'json_arguments' is a JSON string
// that the dialog can fetch using Chrome's JavaScript DOM bindings.  This call
// will block until the dialog is closed.  On success, 'json_retval' will
// contain the JSON string sent back by the dialog (using Chrome's JavaScript
// DOM bindings), and CPERR_SUCCESS is returned.  'json_retval' should be freed
// using CPB_Free when done.
typedef CPError (STDCALL *CPB_ShowHtmlDialogModalFunc)(
    CPID id, CPBrowsingContext context, const char* url, int width, int height,
    const char* json_arguments, char** json_retval);

// Similar to CPB_ShowHtmlDialogModalFunc, but does not block.  When the dialog
// is closed, CPP_HtmlDialogClosed is called with the JSON return value and the
// given 'plugin_context', which may be used by the plugin to associate other
// data with the dialog.
typedef CPError (STDCALL *CPB_ShowHtmlDialogFunc)(
    CPID id, CPBrowsingContext context, const char* url, int width, int height,
    const char* json_arguments, void* plugin_context);

// Get the browsing context associated with the given NPAPI instance.
typedef CPBrowsingContext (STDCALL *CPB_GetBrowsingContextFromNPPFunc)(
    struct _NPP* npp);

// Queries for some meta data associated with the given browsing context.  See
// CPBrowsingContextInfoType for possible queries.  If buf_size is too small to
// contain the entire data, the return value will indicate the size required.
// Otherwise, the return value is a CPError or CPERR_SUCCESS.
typedef int (STDCALL *CPB_GetBrowsingContextInfoFunc)(
    CPID id, CPBrowsingContext context, CPBrowsingContextInfoType type,
    void* buf, uint32 buf_size);

// Given an URL string, returns the string of command-line arguments that should
// be passed to start the browser at the given URL.  'arguments' should be freed
// using CPB_Free when done.
typedef CPError (STDCALL *CPB_GetCommandLineArgumentsFunc)(
    CPID id, CPBrowsingContext context, const char* url, char** arguments);

// Asks the browser to let the plugin handle the given UI command.  When the
// command is invoked, the browser will call CPP_HandleCommand.  'command'
// should be an integer identifier.  Currently only builtin commands are
// supported, but in the future we may want to let plugins add custom menu
// commands with their own descriptions.
typedef CPError (STDCALL *CPB_AddUICommandFunc)(CPID id, int command);

//
// Functions related to making network requests.
// Both the host and plugin will implement their own versions of these.
//

// Starts the request.  Returns CPERR_SUCCESS if the request could be started
// immediately, at which point the response info is available to be read.
// Returns CPERR_IO_PENDING if an asynchronous operation was started, and the
// caller should wait for CPRR_StartCompleted to be called before reading the
// response info.  Returns an error code on failure.
typedef CPError (STDCALL *CPR_StartRequestFunc)(CPRequest* request);

// Stops or cancels the request.  The caller should not access the request
// object after this call.  If an asynchronous IO operation is pending, the
// operation is aborted and the caller will not receive a callback for it.
typedef void (STDCALL *CPR_EndRequestFunc)(CPRequest* request, CPError reason);

// Sets the additional request headers to append to the standard headers that
// would normally be made with this request.  Headers should be \r\n-delimited,
// with no terminating \r\n.  Extra headers are not checked against the standard
// headers for duplicates. Must be called before CPRR_StartCompletedFunc.
// Plugins should avoid setting the following headers: User-Agent,
// Content-Length.
typedef void (STDCALL *CPR_SetExtraRequestHeadersFunc)(CPRequest* request,
                                                       const char* headers);

// Sets the load flags for this request. 'flags' is a bitwise-OR of
// CPRequestLoadFlags.  Must be called before CPRR_StartCompletedFunc.
typedef void (STDCALL *CPR_SetRequestLoadFlagsFunc)(CPRequest* request,
                                                    uint32 flags);

// Appends binary data to the request body of a POST or PUT request.  The caller
// should set the "Content-Type" header to the appropriate mime type using
// CPR_SetExtraRequestHeadersFunc.  This can be called multiple times to append
// a sequence of data segments to upload.  Must be called before
// CPR_StartRequestFunc.
typedef void (STDCALL *CPR_AppendDataToUploadFunc)(
    CPRequest* request, const char* bytes, int bytes_len);

// Appends the contents of a file to the request body of a POST or PUT request.
// 'offset' and 'length' can be used to append a subset of the file. Pass zero
// for 'length' and 'offset' to upload the entire file. 'offset'
// indicates where the data to upload begins in the file. 'length' indicates
// how much of the file to upload. A 'length' of zero is interpretted as to
// end-of-file. If 'length' and 'offset' indicate a range beyond end of file,
// the amount sent is clipped at eof.
// See CPR_AppendDataToUploadFunc for additional usage information.
// (added in v0.4)
typedef CPError (STDCALL *CPR_AppendFileToUploadFunc)(
    CPRequest* request, const char* filepath, uint64 offset, uint64 length);

// Queries for some response meta data.  See CPResponseInfoType for possible
// queries.  If buf_size is too small to contain the entire data, the return
// value will indicate the size required.  Otherwise, the return value is a
// CPError or CPERR_SUCCESS.
typedef int (STDCALL *CPR_GetResponseInfoFunc)(
    CPRequest* request, CPResponseInfoType type,
    void* buf, uint32 buf_size);

// Attempts to read a request's response data.  The number of bytes read is
// returned; 0 indicates an EOF.  CPERR_IO_PENDING is returned if an
// asynchronous operation was started, and CPRR_ReadCompletedFunc will be called
// when it completes; 'buf' must be available until the operation completes.
// Returns an error code on failure.
typedef int (STDCALL *CPR_ReadFunc)(
    CPRequest* request, void* buf, uint32 buf_size);

//
// Functions related to serving network requests.
// Both the host and plugin will implement their own versions of these.
//

// Called upon a server-initiated redirect.  The request will still hold the
// original URL, and 'new_url' will be the redirect destination.
typedef void (STDCALL *CPRR_ReceivedRedirectFunc)(CPRequest* request,
                                                  const char* new_url);

// Called when an asynchronous CPR_StartRequest call has completed, once all
// redirects are followed.  On success, 'result' holds CPERR_SUCCESS and the
// response info is available to be read via CPR_GetResponseInfo.  On error,
// 'result' holds the error code.
typedef void (STDCALL *CPRR_StartCompletedFunc)(CPRequest* request,
                                                CPError result);

// Called when an asynchronous CPR_Read call has completed.  On success,
// 'bytes_read' will hold the number of bytes read into the buffer that was
// passed to CPR_Read; 0 indicates an EOF, and the request object will be
// destroyed after the call completes.  On failure, 'bytes_read' holds the error
// code.
typedef void (STDCALL *CPRR_ReadCompletedFunc)(CPRequest* request,
                                               int bytes_read);

// Called as upload progress is being made for async POST requests.
// (added in v0.5)
typedef void (STDCALL *CPRR_UploadProgressFunc)(CPRequest* request,
                                                uint64 position,
                                                uint64 size);

//
// Functions to support the sending and receipt of messages between processes.
//

// Returns true if the plugin process is running
typedef CPBool (STDCALL *CPB_IsPluginProcessRunningFunc)(CPID id);

// Returns the type of the current process.
typedef CPProcessType (STDCALL *CPB_GetProcessTypeFunc)(CPID id);

// Asks the browser to send raw data to the other process hosting an instance of
// this plugin. If needed, the plugin process will be started prior to sending
// the message.
typedef CPError (STDCALL *CPB_SendMessageFunc)(CPID id,
                                               const void *data,
                                               uint32 data_len);

// Asks the browser to send raw data to the other process hosting an instance of
// this plugin. This function only works from the plugin or renderer process.
// This function blocks until the message is processed.  The memory should be
// freed using CPB_Free when done.
typedef CPError (STDCALL *CPB_SendSyncMessageFunc)(CPID id,
                                                   const void *data,
                                                   uint32 data_len,
                                                   void **retval,
                                                   uint32 *retval_len);

// This function asynchronously calls the provided function on the plugin
// thread.  user_data is passed as the argument to the function.
typedef CPError (STDCALL *CPB_PluginThreadAsyncCallFunc)(CPID id,
                                                         void (*func)(void *),
                                                         void *user_data);

// This function creates an open file dialog.  The process is granted access
// to any files that are selected.  |multiple_files| determines if more than
// one file can be selected.
typedef CPError (STDCALL *CPB_OpenFileDialogFunc)(CPID id,
                                                  CPBrowsingContext context,
                                                  bool multiple_files,
                                                  const char *title,
                                                  const char *filter,
                                                  void *user_data);

// Informs the plugin of raw data having been sent from another process.
typedef void (STDCALL *CPP_OnMessageFunc)(void *data, uint32 data_len);

// Informs the plugin of raw data having been sent from another process.
typedef void (STDCALL *CPP_OnSyncMessageFunc)(void *data, uint32 data_len,
                                              void **retval,
                                              uint32 *retval_len);

// Informs the plugin that the file dialog has completed, and contains the
// results.
typedef void (STDCALL *CPP_OnFileDialogResultFunc)(void *data,
                                                   const char **files,
                                                   uint32 files_len);

// Asks the browser to verify that NPObject* 'event' is the current drag event
// the browser is dispatching, and extract drag data from the event if so.  On
// success, returns the drag 'identity' (an up-counter that the browser chrome
// increases each time a user drag enters a renderer tab), the drag 'event_id'
// and the 'drag_type' being a utf8 encoded string with values "Files", "Text"
// or "URL".  If 'add_data' is true, also return the 'drag_data', again a utf8
// encoded string with the data for the drag type.  For drag type "Files", the
// data is a backspace delimited list of file paths.
//
// The call fails with a CPError if 'event' is an invalid drag event, and sets
// the 'identity' and 'event_id' to 0.  Note: on success, non-NULL 'drag_type'
// and 'drag_data' should be freed with CPB_Free() when done.
typedef CPError (STDCALL *CPB_GetDragDataFunc)(
    CPID id, CPBrowsingContext context, struct NPObject* event, bool add_data,
    int32* identity, int32* event_id, char** drag_type, char** drag_data);

// Asks the browser to verify that NPObject* 'event' is the current drag event
// the browser is dispatching and show the requested drop 'effect' if so.  The
// browser displays drop effects during dragenter and dragover events, to give
// user visible feedback (with a drag cursor, typically) to indicate whether a
// subsequent drop event will succeed or not.  The implementation supports the
// so-called "copy" and "none" effects.  When 'effect' is non-zero, the "copy"
// effect is shown.  Otherwise, the "none" effect is shown, which prevents the
// subsequent drop event from succeeding.  Returns CPError on failure, meaning
// the 'event' is an invalid drag event.
//
// Note: 'effect' is int to allow for new effects in future.  For example, the
// HTML5-defined drop effects "move" and "link".
typedef CPError (STDCALL *CPB_SetDropEffectFunc)(
    CPID id, CPBrowsingContext context, struct NPObject* event, int effect);

// For drag type "Files", the drag data returned by CPB_GetDragDataFunc() is a
// backspace delimited list of file paths.  Use this routine to pass that data
// to the browser process to verify that the renderer has permission to access
// the files.  Returns CPERR_SUCCESS if access is allowed.
typedef CPError (STDCALL *CPB_AllowFileDropFunc)(
    CPID id, CPBrowsingContext context, const char* file_drag_data);

// Function table for issuing requests using via the other side's network stack.
// For the plugin, this functions deal with issuing requests through the
// browser.  For the browser, these functions deal with allowing the plugin to
// intercept requests.
typedef struct _CPRequestFuncs {
  uint16 size;
  CPR_SetExtraRequestHeadersFunc set_extra_request_headers;
  CPR_SetRequestLoadFlagsFunc set_request_load_flags;
  CPR_AppendDataToUploadFunc append_data_to_upload;
  CPR_StartRequestFunc start_request;
  CPR_EndRequestFunc end_request;
  CPR_GetResponseInfoFunc get_response_info;
  CPR_ReadFunc read;
  CPR_AppendFileToUploadFunc append_file_to_upload;
} CPRequestFuncs;

// Function table for handling requests issued by the other side.  For the
// plugin, these deal with serving requests that the plugin has intercepted. For
// the browser, these deal with serving requests that the plugin has issued
// through us.
typedef struct _CPResponseFuncs {
  uint16 size;
  CPRR_ReceivedRedirectFunc received_redirect;
  CPRR_StartCompletedFunc start_completed;
  CPRR_ReadCompletedFunc read_completed;
  CPRR_UploadProgressFunc upload_progress;
} CPResponseFuncs;

// Function table of CPP functions (functions provided by plugin to host). This
// structure is filled in by the plugin in the CP_Initialize call, except for
// the 'size' field, which is set by the browser.  The version fields should be
// set to those that the plugin was compiled using.
typedef struct _CPPluginFuncs {
  uint16 size;
  uint16 version;
  CPRequestFuncs* request_funcs;
  CPResponseFuncs* response_funcs;
  CPP_ShutdownFunc shutdown;
  CPP_ShouldInterceptRequestFunc should_intercept_request;
  CPP_OnMessageFunc on_message;
  CPP_HtmlDialogClosedFunc html_dialog_closed;
  CPP_HandleCommandFunc handle_command;
  CPP_OnSyncMessageFunc on_sync_message;
  CPP_OnFileDialogResultFunc on_file_dialog_result;
} CPPluginFuncs;

// Function table CPB functions (functions provided by host to plugin).
// This structure is filled in by the browser and provided to the plugin.  The
// plugin will likely want to save a copy of this structure to make calls
// back to the browser.
typedef struct _CPBrowserFuncs {
  uint16 size;
  uint16 version;
  CPRequestFuncs* request_funcs;
  CPResponseFuncs* response_funcs;
  CPB_EnableRequestInterceptFunc enable_request_intercept;
  CPB_CreateRequestFunc create_request;
  CPB_GetCookiesFunc get_cookies;
  CPB_AllocFunc alloc;
  CPB_FreeFunc free;
  CPB_SetKeepProcessAliveFunc set_keep_process_alive;
  CPB_ShowHtmlDialogModalFunc show_html_dialog_modal;
  CPB_ShowHtmlDialogFunc show_html_dialog;
  CPB_IsPluginProcessRunningFunc is_plugin_process_running;
  CPB_GetProcessTypeFunc get_process_type;
  CPB_SendMessageFunc send_message;
  CPB_GetBrowsingContextFromNPPFunc get_browsing_context_from_npp;
  CPB_GetBrowsingContextInfoFunc get_browsing_context_info;
  CPB_GetCommandLineArgumentsFunc get_command_line_arguments;
  CPB_AddUICommandFunc add_ui_command;
  CPB_HandleCommandFunc handle_command;
  CPB_SendSyncMessageFunc send_sync_message;
  CPB_PluginThreadAsyncCallFunc plugin_thread_async_call;
  CPB_OpenFileDialogFunc open_file_dialog;
  CPB_GetDragDataFunc get_drag_data;
  CPB_SetDropEffectFunc set_drop_effect;
  CPB_AllowFileDropFunc allow_file_drop;
} CPBrowserFuncs;


//
// DLL exports
//

// This export is optional.
// Prior to calling CP_Initialize, the browser may negotiate with the plugin
// regarding which version of the CPAPI to utilize. 'min_version' is the
// lowest version of the interface supported by the browser, 'max_version' is
// the highest supported version. The plugin can specify which version within
// the range should be used. This version will be reflected in the version field
// of the CPBrowserFuncs struct passed to CP_Initialize. If this function
// returns an error code, CP_Initialize will not be called. If function is not
// exported by the chrome plugin module, CP_Initiailize will be called with
// a version of the host's choosing.
typedef CPError (STDCALL *CP_VersionNegotiateFunc)(
  uint16 min_version, uint16 max_version, uint16 *selected_version);

// 'bfuncs' are the browser functions provided to the plugin. 'id' is the
// plugin identifier that the plugin should use when calling browser functions.
// The plugin should initialize 'pfuncs' with pointers to its own functions,
// or return an error code.
// All functions and entry points should be called on the same thread.  The
// plugin should not attempt to call a browser function from a thread other
// than the one CP_InitializeFunc is called from.
typedef CPError (STDCALL *CP_InitializeFunc)(
    CPID id, const CPBrowserFuncs* bfuncs, CPPluginFuncs* pfuncs);

#ifdef __cplusplus
} // extern "C"
#endif

#endif  // CHROME_COMMON_CHROME_PLUGIN_API_H_