Home | History | Annotate | Download | only in npapi 
      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 // A proxy for NPObject that sends all calls to the object to an NPObjectStub
      6 // running in a different process.
      7 
      8 #ifndef CONTENT_CHILD_NPAPI_NPOBJECT_PROXY_H_
      9 #define CONTENT_CHILD_NPAPI_NPOBJECT_PROXY_H_
     10 
     11 #include "base/memory/ref_counted.h"
     12 #include "content/child/npapi/npobject_base.h"
     13 #include "ipc/ipc_listener.h"
     14 #include "ipc/ipc_sender.h"
     15 #include "third_party/npapi/bindings/npruntime.h"
     16 #include "ui/gfx/native_widget_types.h"
     17 #include "url/gurl.h"
     18 
     19 struct NPObject;
     20 
     21 namespace content {
     22 class NPChannelBase;
     23 
     24 // When running a plugin in a different process from the renderer, we need to
     25 // proxy calls to NPObjects across process boundaries.  This happens both ways,
     26 // as a plugin can get an NPObject for the window, and a page can get an
     27 // NPObject for the plugin.  In the process that interacts with the NPobject we
     28 // give it an NPObjectProxy instead.  All calls to it are sent across an IPC
     29 // channel (specifically, a NPChannelBase).  The NPObjectStub on the other
     30 // side translates the IPC messages into calls to the actual NPObject, and
     31 // returns the marshalled result.
     32 class NPObjectProxy : public IPC::Listener,
     33                       public IPC::Sender,
     34                       public NPObjectBase {
     35  public:
     36   virtual ~NPObjectProxy();
     37 
     38   static NPObject* Create(NPChannelBase* channel,
     39                           int route_id,
     40                           int render_view_id,
     41                           const GURL& page_url,
     42                           NPP owner);
     43 
     44   // IPC::Sender implementation:
     45   virtual bool Send(IPC::Message* msg) OVERRIDE;
     46   int route_id() { return route_id_; }
     47   NPChannelBase* channel() { return channel_.get(); }
     48 
     49   // The next 9 functions are called on NPObjects from the plugin and browser.
     50   static bool NPHasMethod(NPObject *obj,
     51                           NPIdentifier name);
     52   static bool NPInvoke(NPObject *obj,
     53                        NPIdentifier name,
     54                        const NPVariant *args,
     55                        uint32_t arg_count,
     56                        NPVariant *result);
     57   static bool NPInvokeDefault(NPObject *npobj,
     58                               const NPVariant *args,
     59                               uint32_t arg_count,
     60                               NPVariant *result);
     61   static bool NPHasProperty(NPObject *obj,
     62                             NPIdentifier name);
     63   static bool NPGetProperty(NPObject *obj,
     64                             NPIdentifier name,
     65                             NPVariant *result);
     66   static bool NPSetProperty(NPObject *obj,
     67                             NPIdentifier name,
     68                             const NPVariant *value);
     69   static bool NPRemoveProperty(NPObject *obj,
     70                                NPIdentifier name);
     71   static bool NPNEnumerate(NPObject *obj,
     72                            NPIdentifier **value,
     73                            uint32_t *count);
     74   static bool NPNConstruct(NPObject *npobj,
     75                            const NPVariant *args,
     76                            uint32_t arg_count,
     77                            NPVariant *result);
     78 
     79   // The next two functions are only called on NPObjects from the browser.
     80   static bool NPNEvaluate(NPP npp,
     81                           NPObject *obj,
     82                           NPString *script,
     83                           NPVariant *result);
     84 
     85   static bool NPInvokePrivate(NPP npp,
     86                               NPObject *obj,
     87                               bool is_default,
     88                               NPIdentifier name,
     89                               const NPVariant *args,
     90                               uint32_t arg_count,
     91                               NPVariant *result);
     92 
     93   static NPObjectProxy* GetProxy(NPObject* object);
     94   static const NPClass* npclass() { return &npclass_proxy_; }
     95 
     96   // NPObjectBase implementation.
     97   virtual NPObject* GetUnderlyingNPObject() OVERRIDE;
     98 
     99   virtual IPC::Listener* GetChannelListener() OVERRIDE;
    100 
    101  private:
    102   NPObjectProxy(NPChannelBase* channel,
    103                 int route_id,
    104                 int render_view_id,
    105                 const GURL& page_url);
    106 
    107   // IPC::Listener implementation:
    108   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
    109   virtual void OnChannelError() OVERRIDE;
    110 
    111   static NPObject* NPAllocate(NPP, NPClass*);
    112   static void NPDeallocate(NPObject* npObj);
    113 
    114   // This function is only caled on NPObjects from the plugin.
    115   static void NPPInvalidate(NPObject *obj);
    116   static NPClass npclass_proxy_;
    117 
    118   scoped_refptr<NPChannelBase> channel_;
    119   int route_id_;
    120   int render_view_id_;
    121 
    122   // The url of the main frame hosting the plugin.
    123   GURL page_url_;
    124 };
    125 
    126 }  // namespace content
    127 
    128 #endif  // CONTENT_CHILD_NPAPI_NPOBJECT_PROXY_H_
    129