Convert audio-related messages to the new thunk/API system for Pepper.

This has a bit of a change from the previous couple of resources that were
converted in that the ResourceCreationProxy now calls a static proxy function
for actually doing the work. It became too complicated and required that the
ResourceCreationProxy know a lot about the internals of the objects.

Did a little namespace cleanup. This renames "pp::shared_impl" to just use the
"ppapi" namespace. The "shared_impl" was ugly and didn't help anything. Some
files in that directory used "ppapi::shared_impl" instead which was even more
confusing.

Do a little build cleanup. The old ppapi_shared_proxy.gypi is now split into
two sub-files, one for ppapi_shared, and one for ppapi_proxy. It's hopefully
easier to find stuff now.
Review URL: http://codereview.chromium.org/7014024

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@85303 0039d316-1c4b-4281-b951-d872f2087c98

21 files changed, 260 insertions, 276 deletions

diff --git a/ppapi/proxy/dispatcher.h b/ppapi/proxy/dispatcher.h
index 2dd8052..2dc1fe6 100644
--- a/ppapi/proxy/dispatcher.h
+++ b/ppapi/proxy/dispatcher.h
@@ -20,12 +20,11 @@
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/plugin_var_tracker.h"
 
-namespace pp {
-
-namespace shared_impl {
+namespace ppapi {
 class WebKitForwarding;
 }
 
+namespace pp {
 namespace proxy {
 
 class VarSerializationRules;
@@ -60,7 +59,7 @@ class Dispatcher : public ProxyChannel {
 
     // Returns the WebKit forwarding object used to make calls into WebKit.
     // Necessary only on the plugin side. The host side can return NULL.
-    virtual pp::shared_impl::WebKitForwarding* GetWebKitForwarding() = 0;
+    virtual ppapi::WebKitForwarding* GetWebKitForwarding() = 0;
 
     // Posts the given task to the WebKit thread associated with this plugin
     // process. For host processes, this will not be called and can do
diff --git a/ppapi/proxy/host_dispatcher.h b/ppapi/proxy/host_dispatcher.h
index 29d3c25..608223d 100644
--- a/ppapi/proxy/host_dispatcher.h
+++ b/ppapi/proxy/host_dispatcher.h
@@ -119,7 +119,7 @@ class HostDispatcher : public Dispatcher {
   // Function proxies created for "new-style" FunctionGroups.
   // TODO(brettw) this is in progress. It should be merged with the target
   // proxies so there is one list to consult.
-  scoped_ptr< ::ppapi::shared_impl::FunctionGroupBase >
+  scoped_ptr< ::ppapi::FunctionGroupBase >
       function_proxies_[INTERFACE_ID_COUNT];
 
   // Guaranteed non-NULL.
diff --git a/ppapi/proxy/host_resource.h b/ppapi/proxy/host_resource.h
index badd2fd..fe1abb2 100644
--- a/ppapi/proxy/host_resource.h
+++ b/ppapi/proxy/host_resource.h
@@ -27,6 +27,16 @@ class HostResource {
     return !host_resource_;
   }
 
+  // Some resources are plugin-side only and don't have a corresponding
+  // resource in the host. Yet these resources still need an instance to be
+  // associated with. This function creates a HostResource with the given
+  // instances and a 0 host resource ID for these cases.
+  static HostResource MakeInstanceOnly(PP_Instance instance) {
+    HostResource resource;
+    resource.SetHostResource(instance, 0);
+    return resource;
+  }
+
   // Sets and retrieves the internal PP_Resource which is valid for the host
   // (a.k.a. renderer, as opposed to the plugin) process.
   //
diff --git a/ppapi/proxy/plugin_dispatcher.cc b/ppapi/proxy/plugin_dispatcher.cc
index 2a79e91..b8ac146 100644
--- a/ppapi/proxy/plugin_dispatcher.cc
+++ b/ppapi/proxy/plugin_dispatcher.cc
@@ -45,7 +45,7 @@ PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
   // GetInterface call or name for it, so we insert it into our table now.
   target_proxies_[INTERFACE_ID_PPP_CLASS].reset(new PPP_Class_Proxy(this));
 
-  ::ppapi::shared_impl::TrackerBase::Init(
+  ::ppapi::TrackerBase::Init(
       &PluginResourceTracker::GetTrackerBaseInstance);
 }
 
@@ -208,11 +208,11 @@ void PluginDispatcher::PostToWebKitThread(
   return dispatcher_delegate_->PostToWebKitThread(from_here, task);
 }
 
-pp::shared_impl::WebKitForwarding* PluginDispatcher::GetWebKitForwarding() {
+ppapi::WebKitForwarding* PluginDispatcher::GetWebKitForwarding() {
   return dispatcher_delegate_->GetWebKitForwarding();
 }
 
-::ppapi::shared_impl::FunctionGroupBase* PluginDispatcher::GetFunctionAPI(
+::ppapi::FunctionGroupBase* PluginDispatcher::GetFunctionAPI(
     pp::proxy::InterfaceID id) {
   if (function_proxies_[id].get())
     return function_proxies_[id].get();
diff --git a/ppapi/proxy/plugin_dispatcher.h b/ppapi/proxy/plugin_dispatcher.h
index 959a7ac..65c4c82 100644
--- a/ppapi/proxy/plugin_dispatcher.h
+++ b/ppapi/proxy/plugin_dispatcher.h
@@ -80,13 +80,13 @@ class PluginDispatcher : public Dispatcher {
                           const base::Closure& task);
 
   // Returns the WebKitForwarding object used to forward events to WebKit.
-  pp::shared_impl::WebKitForwarding* GetWebKitForwarding();
+  ppapi::WebKitForwarding* GetWebKitForwarding();
 
   // Returns the "new-style" function API for the given interface ID, creating
   // it if necessary.
   // TODO(brettw) this is in progress. It should be merged with the target
   // proxies so there is one list to consult.
-  ::ppapi::shared_impl::FunctionGroupBase* GetFunctionAPI(
+  ppapi::FunctionGroupBase* GetFunctionAPI(
       pp::proxy::InterfaceID id);
 
  private:
@@ -106,7 +106,7 @@ class PluginDispatcher : public Dispatcher {
   // Function proxies created for "new-style" FunctionGroups.
   // TODO(brettw) this is in progress. It should be merged with the target
   // proxies so there is one list to consult.
-  scoped_ptr< ::ppapi::shared_impl::FunctionGroupBase >
+  scoped_ptr< ::ppapi::FunctionGroupBase >
       function_proxies_[INTERFACE_ID_COUNT];
 
   typedef base::hash_map<PP_Instance, InstanceData> InstanceDataMap;
diff --git a/ppapi/proxy/plugin_resource.h b/ppapi/proxy/plugin_resource.h
index 5009af8..eff74b4 100644
--- a/ppapi/proxy/plugin_resource.h
+++ b/ppapi/proxy/plugin_resource.h
@@ -42,7 +42,7 @@ namespace proxy {
 FOR_ALL_PLUGIN_RESOURCES(DECLARE_RESOURCE_CLASS)
 #undef DECLARE_RESOURCE_CLASS
 
-class PluginResource : public ::ppapi::shared_impl::ResourceObjectBase {
+class PluginResource : public ::ppapi::ResourceObjectBase {
  public:
   PluginResource(const HostResource& resource);
   virtual ~PluginResource();
diff --git a/ppapi/proxy/plugin_resource_tracker.cc b/ppapi/proxy/plugin_resource_tracker.cc
index 24d1281..a6e087f 100644
--- a/ppapi/proxy/plugin_resource_tracker.cc
+++ b/ppapi/proxy/plugin_resource_tracker.cc
@@ -20,7 +20,7 @@ namespace {
 // When non-NULL, this object overrides the ResourceTrackerSingleton.
 PluginResourceTracker* g_resource_tracker_override = NULL;
 
-::ppapi::shared_impl::TrackerBase* GetTrackerBase() {
+::ppapi::TrackerBase* GetTrackerBase() {
   return PluginResourceTracker::GetInstance();
 }
 
@@ -39,7 +39,7 @@ PluginResourceTracker::ResourceInfo::ResourceInfo(const ResourceInfo& other)
     : ref_count(other.ref_count),
       resource(other.resource) {
   // Wire up the new shared resource tracker base to use our implementation.
-  ::ppapi::shared_impl::TrackerBase::Init(&GetTrackerBase);
+  ::ppapi::TrackerBase::Init(&GetTrackerBase);
 }
 
 PluginResourceTracker::ResourceInfo::~ResourceInfo() {
@@ -75,7 +75,7 @@ PluginResourceTracker* PluginResourceTracker::GetInstance() {
 }
 
 // static
-::ppapi::shared_impl::TrackerBase*
+::ppapi::TrackerBase*
 PluginResourceTracker::GetTrackerBaseInstance() {
   return GetInstance();
 }
@@ -122,7 +122,7 @@ PP_Resource PluginResourceTracker::PluginResourceForHostResource(
   return found->second;
 }
 
-::ppapi::shared_impl::ResourceObjectBase* PluginResourceTracker::GetResourceAPI(
+::ppapi::ResourceObjectBase* PluginResourceTracker::GetResourceAPI(
     PP_Resource res) {
   ResourceMap::iterator found = resource_map_.find(res);
   if (found == resource_map_.end())
@@ -130,7 +130,7 @@ PP_Resource PluginResourceTracker::PluginResourceForHostResource(
   return found->second.resource.get();
 }
 
-::ppapi::shared_impl::FunctionGroupBase* PluginResourceTracker::GetFunctionAPI(
+::ppapi::FunctionGroupBase* PluginResourceTracker::GetFunctionAPI(
     PP_Instance inst,
     pp::proxy::InterfaceID id) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(inst);
diff --git a/ppapi/proxy/plugin_resource_tracker.h b/ppapi/proxy/plugin_resource_tracker.h
index 268709f..5dfdf82 100644
--- a/ppapi/proxy/plugin_resource_tracker.h
+++ b/ppapi/proxy/plugin_resource_tracker.h
@@ -25,7 +25,7 @@ namespace proxy {
 class PluginDispatcher;
 class PluginResource;
 
-class PluginResourceTracker : public ::ppapi::shared_impl::TrackerBase {
+class PluginResourceTracker : public ::ppapi::TrackerBase {
  public:
   // Called by tests that want to specify a specific ResourceTracker. This
   // allows them to use a unique one each time and avoids singletons sticking
@@ -34,7 +34,7 @@ class PluginResourceTracker : public ::ppapi::shared_impl::TrackerBase {
 
   // Returns the global singleton resource tracker for the plugin.
   static PluginResourceTracker* GetInstance();
-  static ::ppapi::shared_impl::TrackerBase* GetTrackerBaseInstance();
+  static ::ppapi::TrackerBase* GetTrackerBaseInstance();
 
   // Returns the object associated with the given resource ID, or NULL if
   // there isn't one.
@@ -55,9 +55,9 @@ class PluginResourceTracker : public ::ppapi::shared_impl::TrackerBase {
       const HostResource& resource) const;
 
   // TrackerBase.
-  virtual ::ppapi::shared_impl::ResourceObjectBase* GetResourceAPI(
+  virtual ::ppapi::ResourceObjectBase* GetResourceAPI(
       PP_Resource res);
-  virtual ::ppapi::shared_impl::FunctionGroupBase* GetFunctionAPI(
+  virtual ::ppapi::FunctionGroupBase* GetFunctionAPI(
       PP_Instance inst,
       pp::proxy::InterfaceID id);
 
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index a5decc8..d00e6d0 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -250,26 +250,15 @@ IPC_MESSAGE_CONTROL1(PpapiHostMsg_ChannelCreated,
                      IPC::ChannelHandle /* handle */)
 
 // PPB_Audio.
-IPC_SYNC_MESSAGE_ROUTED2_1(PpapiHostMsg_PPBAudio_Create,
+IPC_SYNC_MESSAGE_ROUTED3_1(PpapiHostMsg_PPBAudio_Create,
                            PP_Instance /* instance_id */,
-                           pp::proxy::HostResource /* config_id */,
+                           int32_t /* sample_rate */,
+                           uint32_t /* sample_frame_count */,
                            pp::proxy::HostResource /* result */)
 IPC_MESSAGE_ROUTED2(PpapiHostMsg_PPBAudio_StartOrStop,
                     pp::proxy::HostResource /* audio_id */,
                     bool /* play */)
 
-// PPB_AudioConfig.
-IPC_SYNC_MESSAGE_ROUTED3_1(PpapiHostMsg_PPBAudioConfig_Create,
-                           PP_Instance /* instance */,
-                           int32_t /* sample_rate */,
-                           uint32_t /* sample_frame_count */,
-                           pp::proxy::HostResource /* result */)
-IPC_SYNC_MESSAGE_ROUTED2_1(
-    PpapiHostMsg_PPBAudioConfig_RecommendSampleFrameCount,
-    int32_t /* sample_rate */,
-    uint32_t /* requested */,
-    uint32_t /* result */)
-
 // PPB_Broker.
 IPC_SYNC_MESSAGE_ROUTED1_1(PpapiHostMsg_PPBBroker_Create,
                            PP_Instance /* instance */,
diff --git a/ppapi/proxy/ppb_audio_config_proxy.cc b/ppapi/proxy/ppb_audio_config_proxy.cc
index 0c8eaab..8e78ecd 100644
--- a/ppapi/proxy/ppb_audio_config_proxy.cc
+++ b/ppapi/proxy/ppb_audio_config_proxy.cc
@@ -8,92 +8,39 @@
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/audio_config_impl.h"
+#include "ppapi/thunk/thunk.h"
 
 namespace pp {
 namespace proxy {
 
-class AudioConfig : public PluginResource {
+// The implementation is actually in AudioConfigImpl.
+class AudioConfig : public PluginResource,
+                    public ppapi::AudioConfigImpl {
  public:
-  AudioConfig(const HostResource& resource,
-              PP_AudioSampleRate sample_rate,
-              uint32_t sample_frame_count)
-      : PluginResource(resource),
-        sample_rate_(sample_rate),
-        sample_frame_count_(sample_frame_count) {
-  }
-  virtual ~AudioConfig() {}
+  // Note that you must call Init (on AudioConfigImpl) before using this class.
+  AudioConfig(const HostResource& resource);
+  virtual ~AudioConfig();
 
-  // Resource overrides.
-  virtual AudioConfig* AsAudioConfig() { return this; }
-
-  PP_AudioSampleRate sample_rate() const { return sample_rate_; }
-  uint32_t sample_frame_count() const { return sample_frame_count_; }
+  // ResourceObjectBase overrides.
+  virtual ::ppapi::thunk::PPB_AudioConfig_API* AsAudioConfig_API() OVERRIDE;
 
  private:
-  PP_AudioSampleRate sample_rate_;
-  uint32_t sample_frame_count_;
-
   DISALLOW_COPY_AND_ASSIGN(AudioConfig);
 };
 
-namespace {
-
-PP_Resource CreateStereo16bit(PP_Instance instance,
-                              PP_AudioSampleRate sample_rate,
-                              uint32_t sample_frame_count) {
-  HostResource resource;
-  PluginDispatcher::GetForInstance(instance)->Send(
-      new PpapiHostMsg_PPBAudioConfig_Create(
-          INTERFACE_ID_PPB_AUDIO_CONFIG, instance,
-          static_cast<int32_t>(sample_rate), sample_frame_count,
-          &resource));
-  if (resource.is_null())
-    return 0;
-
-  linked_ptr<AudioConfig> object(
-      new AudioConfig(resource, sample_rate, sample_frame_count));
-  return PluginResourceTracker::GetInstance()->AddResource(object);
-}
-
-uint32_t RecommendSampleFrameCount(PP_AudioSampleRate sample_rate,
-                                   uint32_t requested_sample_frame_count) {
-  // TODO(brettw) Currently we don't actually query to get a value from the
-  // hardware, so we always return the input for in-range values.
-  //
-  // Danger: this code is duplicated in the audio config implementation.
-  if (requested_sample_frame_count < PP_AUDIOMINSAMPLEFRAMECOUNT)
-    return PP_AUDIOMINSAMPLEFRAMECOUNT;
-  if (requested_sample_frame_count > PP_AUDIOMAXSAMPLEFRAMECOUNT)
-    return PP_AUDIOMAXSAMPLEFRAMECOUNT;
-  return requested_sample_frame_count;
+AudioConfig::AudioConfig(const HostResource& resource)
+    : PluginResource(resource) {
 }
 
-PP_Bool IsAudioConfig(PP_Resource resource) {
-  AudioConfig* object = PluginResource::GetAs<AudioConfig>(resource);
-  return BoolToPPBool(!!object);
+AudioConfig::~AudioConfig() {
 }
 
-PP_AudioSampleRate GetSampleRate(PP_Resource config_id) {
-  AudioConfig* object = PluginResource::GetAs<AudioConfig>(config_id);
-  if (!object)
-    return PP_AUDIOSAMPLERATE_NONE;
-  return object->sample_rate();
+::ppapi::thunk::PPB_AudioConfig_API* AudioConfig::AsAudioConfig_API() {
+  return this;
 }
 
-uint32_t GetSampleFrameCount(PP_Resource config_id) {
-  AudioConfig* object = PluginResource::GetAs<AudioConfig>(config_id);
-  if (!object)
-    return 0;
-  return object->sample_frame_count();
-}
-
-const PPB_AudioConfig audio_config_interface = {
-  &CreateStereo16bit,
-  &RecommendSampleFrameCount,
-  &IsAudioConfig,
-  &GetSampleRate,
-  &GetSampleFrameCount
-};
+namespace {
 
 InterfaceProxy* CreateAudioConfigProxy(Dispatcher* dispatcher,
                                        const void* target_interface) {
@@ -113,7 +60,7 @@ PPB_AudioConfig_Proxy::~PPB_AudioConfig_Proxy() {
 // static
 const InterfaceProxy::Info* PPB_AudioConfig_Proxy::GetInfo() {
   static const Info info = {
-    &audio_config_interface,
+    ::ppapi::thunk::GetPPB_AudioConfig_Thunk(),
     PPB_AUDIO_CONFIG_INTERFACE,
     INTERFACE_ID_PPB_AUDIO_CONFIG,
     false,
@@ -122,35 +69,22 @@ const InterfaceProxy::Info* PPB_AudioConfig_Proxy::GetInfo() {
   return &info;
 }
 
-bool PPB_AudioConfig_Proxy::OnMessageReceived(const IPC::Message& msg) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PPB_AudioConfig_Proxy, msg)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioConfig_Create,
-                        OnMsgCreateStereo16Bit)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudioConfig_RecommendSampleFrameCount,
-                        OnMsgRecommendSampleFrameCount)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void PPB_AudioConfig_Proxy::OnMsgCreateStereo16Bit(PP_Instance instance,
-                                                   int32_t sample_rate,
-                                                   uint32_t sample_frame_count,
-                                                   HostResource* result) {
-  result->SetHostResource(instance,
-      ppb_audio_config_target()->CreateStereo16Bit(
-          instance, static_cast<PP_AudioSampleRate>(sample_rate),
-          sample_frame_count));
+// static
+PP_Resource PPB_AudioConfig_Proxy::CreateProxyResource(
+    PP_Instance instance,
+    PP_AudioSampleRate sample_rate,
+    uint32_t sample_frame_count) {
+  linked_ptr<AudioConfig> object(new AudioConfig(
+      HostResource::MakeInstanceOnly(instance)));
+  if (!object->Init(sample_rate, sample_frame_count))
+    return 0;
+  return PluginResourceTracker::GetInstance()->AddResource(object);
 }
 
-void PPB_AudioConfig_Proxy::OnMsgRecommendSampleFrameCount(
-    int32_t sample_rate,
-    uint32_t requested_sample_frame_count,
-    uint32_t* result) {
-  *result = ppb_audio_config_target()->RecommendSampleFrameCount(
-      static_cast<PP_AudioSampleRate>(sample_rate),
-      requested_sample_frame_count);
+bool PPB_AudioConfig_Proxy::OnMessageReceived(const IPC::Message& msg) {
+  // There are no IPC messages for this interface.
+  NOTREACHED();
+  return false;
 }
 
 }  // namespace proxy
diff --git a/ppapi/proxy/ppb_audio_config_proxy.h b/ppapi/proxy/ppb_audio_config_proxy.h
index c6c9588..e8a12e8 100644
--- a/ppapi/proxy/ppb_audio_config_proxy.h
+++ b/ppapi/proxy/ppb_audio_config_proxy.h
@@ -8,6 +8,7 @@
 #include "base/basictypes.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
+#include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/proxy/interface_proxy.h"
 
 struct PPB_AudioConfig;
@@ -24,23 +25,14 @@ class PPB_AudioConfig_Proxy : public InterfaceProxy {
 
   static const Info* GetInfo();
 
-  const PPB_AudioConfig* ppb_audio_config_target() const {
-    return static_cast<const PPB_AudioConfig*>(target_interface());
-  }
+  static PP_Resource CreateProxyResource(PP_Instance instance,
+                                         PP_AudioSampleRate sample_rate,
+                                         uint32_t sample_frame_count);
 
   // InterfaceProxy implementation.
   virtual bool OnMessageReceived(const IPC::Message& msg);
 
  private:
-  // Message handlers.
-  void OnMsgCreateStereo16Bit(PP_Instance instance,
-                              int32_t sample_rate,
-                              uint32_t sample_frame_count,
-                              HostResource* result);
-  void OnMsgRecommendSampleFrameCount(int32_t sample_rate,
-                                      uint32_t requested,
-                                      uint32_t* result);
-
   DISALLOW_COPY_AND_ASSIGN(PPB_AudioConfig_Proxy);
 };
 
diff --git a/ppapi/proxy/ppb_audio_proxy.cc b/ppapi/proxy/ppb_audio_proxy.cc
index 6e34674..6c2cc7a 100644
--- a/ppapi/proxy/ppb_audio_proxy.cc
+++ b/ppapi/proxy/ppb_audio_proxy.cc
@@ -7,122 +7,92 @@
 #include "base/threading/simple_thread.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio.h"
+#include "ppapi/c/ppb_audio_config.h"
+#include "ppapi/c/ppb_var.h"
 #include "ppapi/c/trusted/ppb_audio_trusted.h"
 #include "ppapi/proxy/interface_id.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/audio_impl.h"
+#include "ppapi/thunk/ppb_audio_config_api.h"
+#include "ppapi/thunk/ppb_audio_trusted_api.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/resource_creation_api.h"
+#include "ppapi/thunk/thunk.h"
 
 namespace pp {
 namespace proxy {
 
-class Audio : public PluginResource, public pp::shared_impl::AudioImpl {
+class Audio : public PluginResource, public ppapi::AudioImpl {
  public:
   Audio(const HostResource& audio_id,
         PP_Resource config_id,
         PPB_Audio_Callback callback,
-        void* user_data)
-      : PluginResource(audio_id),
-        config_(config_id) {
-    SetCallback(callback, user_data);
-    PluginResourceTracker::GetInstance()->AddRefResource(config_);
-  }
-  virtual ~Audio() {
-    PluginResourceTracker::GetInstance()->ReleaseResource(config_);
-  }
-
-  // Resource overrides.
-  virtual Audio* AsAudio() { return this; }
+        void* user_data);
+  virtual ~Audio();
 
-  PP_Resource config() const { return config_; }
+  // ResourceObjectBase overrides.
+  virtual ::ppapi::thunk::PPB_Audio_API* AsAudio_API();
 
-  void StartPlayback(PP_Resource resource) {
-    if (playing())
-      return;
-    SetStartPlaybackState();
-    PluginDispatcher::GetForInstance(instance())->Send(
-        new PpapiHostMsg_PPBAudio_StartOrStop(
-            INTERFACE_ID_PPB_AUDIO, host_resource(), true));
-  }
-
-  void StopPlayback(PP_Resource resource) {
-    if (!playing())
-      return;
-    PluginDispatcher::GetForInstance(instance())->Send(
-        new PpapiHostMsg_PPBAudio_StartOrStop(
-            INTERFACE_ID_PPB_AUDIO, host_resource(), false));
-    SetStopPlaybackState();
-  }
+  // PPB_Audio_API implementation.
+  virtual PP_Resource GetCurrentConfig() OVERRIDE;
+  virtual PP_Bool StartPlayback() OVERRIDE;
+  virtual PP_Bool StopPlayback() OVERRIDE;
 
  private:
+  // Owning reference to the current config object. This isn't actually used,
+  // we just dish it out as requested by the plugin.
   PP_Resource config_;
 
   DISALLOW_COPY_AND_ASSIGN(Audio);
 };
 
-namespace {
-
-PP_Resource Create(PP_Instance instance_id,
-                   PP_Resource config_id,
-                   PPB_Audio_Callback callback,
-                   void* user_data) {
-  PluginResource* config = PluginResourceTracker::GetInstance()->
-      GetResourceObject(config_id);
-  if (!config)
-    return 0;
-
-  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance_id);
-  if (!dispatcher)
-    return 0;
-
-  HostResource result;
-  dispatcher->Send(new PpapiHostMsg_PPBAudio_Create(
-      INTERFACE_ID_PPB_AUDIO, instance_id, config->host_resource(), &result));
-  if (result.is_null())
-    return 0;
+Audio::Audio(const HostResource& audio_id,
+             PP_Resource config_id,
+             PPB_Audio_Callback callback,
+             void* user_data)
+    : PluginResource(audio_id),
+      config_(config_id) {
+  SetCallback(callback, user_data);
+  PluginResourceTracker::GetInstance()->AddRefResource(config_);
+}
 
-  linked_ptr<Audio> object(new Audio(result, config_id, callback, user_data));
-  return PluginResourceTracker::GetInstance()->AddResource(object);
+Audio::~Audio() {
+  PluginResourceTracker::GetInstance()->ReleaseResource(config_);
 }
 
-PP_Bool IsAudio(PP_Resource resource) {
-  Audio* object = PluginResource::GetAs<Audio>(resource);
-  return BoolToPPBool(!!object);
+::ppapi::thunk::PPB_Audio_API* Audio::AsAudio_API() {
+  return this;
 }
 
-PP_Resource GetCurrentConfiguration(PP_Resource audio_id) {
-  Audio* object = PluginResource::GetAs<Audio>(audio_id);
-  if (!object)
-    return 0;
-  PP_Resource result = object->config();
-  PluginResourceTracker::GetInstance()->AddRefResource(result);
-  return result;
+PP_Resource Audio::GetCurrentConfig() {
+  // AddRef for the caller.
+  PluginResourceTracker::GetInstance()->AddRefResource(config_);
+  return config_;
 }
 
-PP_Bool StartPlayback(PP_Resource audio_id) {
-  Audio* object = PluginResource::GetAs<Audio>(audio_id);
-  if (!object)
-    return PP_FALSE;
-  object->StartPlayback(audio_id);
+PP_Bool Audio::StartPlayback() {
+  if (playing())
+    return PP_TRUE;
+  SetStartPlaybackState();
+  PluginDispatcher::GetForInstance(instance())->Send(
+      new PpapiHostMsg_PPBAudio_StartOrStop(
+          INTERFACE_ID_PPB_AUDIO, host_resource(), true));
   return PP_TRUE;
 }
 
-PP_Bool StopPlayback(PP_Resource audio_id) {
-  Audio* object = PluginResource::GetAs<Audio>(audio_id);
-  if (!object)
-    return PP_FALSE;
-  object->StopPlayback(audio_id);
+PP_Bool Audio::StopPlayback() {
+  if (!playing())
+    return PP_TRUE;
+  PluginDispatcher::GetForInstance(instance())->Send(
+      new PpapiHostMsg_PPBAudio_StartOrStop(
+          INTERFACE_ID_PPB_AUDIO, host_resource(), false));
+  SetStopPlaybackState();
   return PP_TRUE;
 }
 
-const PPB_Audio audio_interface = {
-  &Create,
-  &IsAudio,
-  &GetCurrentConfiguration,
-  &StartPlayback,
-  &StopPlayback
-};
+namespace {
 
 InterfaceProxy* CreateAudioProxy(Dispatcher* dispatcher,
                                  const void* target_interface) {
@@ -155,7 +125,7 @@ PPB_Audio_Proxy::~PPB_Audio_Proxy() {
 // static
 const InterfaceProxy::Info* PPB_Audio_Proxy::GetInfo() {
   static const Info info = {
-    &audio_interface,
+    ppapi::thunk::GetPPB_Audio_Thunk(),
     PPB_AUDIO_INTERFACE,
     INTERFACE_ID_PPB_AUDIO,
     false,
@@ -164,6 +134,34 @@ const InterfaceProxy::Info* PPB_Audio_Proxy::GetInfo() {
   return &info;
 }
 
+// static
+PP_Resource PPB_Audio_Proxy::CreateProxyResource(
+    PP_Instance instance_id,
+    PP_Resource config_id,
+    PPB_Audio_Callback audio_callback,
+    void* user_data) {
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance_id);
+  if (!dispatcher)
+    return 0;
+
+  ::ppapi::thunk::EnterResourceNoLock< ::ppapi::thunk::PPB_AudioConfig_API>
+      config(config_id, true);
+  if (config.failed())
+    return 0;
+
+  HostResource result;
+  dispatcher->Send(new PpapiHostMsg_PPBAudio_Create(
+      INTERFACE_ID_PPB_AUDIO, instance_id,
+      config.object()->GetSampleRate(), config.object()->GetSampleFrameCount(),
+      &result));
+  if (result.is_null())
+    return 0;
+
+  linked_ptr<Audio> object(new Audio(result, config_id,
+                                     audio_callback, user_data));
+  return PluginResourceTracker::GetInstance()->AddResource(object);
+}
+
 bool PPB_Audio_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Audio_Proxy, msg)
@@ -178,26 +176,45 @@ bool PPB_Audio_Proxy::OnMessageReceived(const IPC::Message& msg) {
 }
 
 void PPB_Audio_Proxy::OnMsgCreate(PP_Instance instance_id,
-                                  const HostResource& config_id,
+                                  int32_t sample_rate,
+                                  uint32_t sample_frame_count,
                                   HostResource* result) {
-  const PPB_AudioTrusted* audio_trusted =
-      reinterpret_cast<const PPB_AudioTrusted*>(
-          dispatcher()->GetLocalInterface(PPB_AUDIO_TRUSTED_INTERFACE));
-  if (!audio_trusted)
+  ::ppapi::thunk::EnterFunction< ::ppapi::thunk::ResourceCreationAPI>
+      resource_creation(instance_id, true);
+  if (resource_creation.failed())
     return;
 
-  result->SetHostResource(instance_id,
-                          audio_trusted->CreateTrusted(instance_id));
+  // Make the resource and get the API pointer to its trusted interface.
+  result->SetHostResource(
+      instance_id,
+      resource_creation.functions()->CreateAudioTrusted(instance_id));
   if (result->is_null())
     return;
+  ::ppapi::thunk::EnterResourceNoLock< ::ppapi::thunk::PPB_AudioTrusted_API>
+      trusted_audio(result->host_resource(), false);
+  if (trusted_audio.failed())
+    return;
 
+  // Make an audio config object.
+  PP_Resource audio_config_res =
+      resource_creation.functions()->CreateAudioConfig(
+          instance_id, static_cast<PP_AudioSampleRate>(sample_rate),
+          sample_frame_count);
+  if (!audio_config_res)
+    return;
+
+  // Initiate opening the audio object.
   CompletionCallback callback = callback_factory_.NewCallback(
       &PPB_Audio_Proxy::AudioChannelConnected, *result);
-  int32_t open_error = audio_trusted->Open(result->host_resource(),
-                                           config_id.host_resource(),
-                                           callback.pp_completion_callback());
+  int32_t open_error = trusted_audio.object()->OpenTrusted(
+      audio_config_res, callback.pp_completion_callback());
   if (open_error != PP_OK_COMPLETIONPENDING)
     callback.Run(open_error);
+
+  // Clean up the temporary audio config resource we made.
+  const PPB_Core* core = static_cast<const PPB_Core*>(
+      dispatcher()->GetLocalInterface(PPB_CORE_INTERFACE));
+  core->ReleaseResource(audio_config_res);
 }
 
 void PPB_Audio_Proxy::OnMsgStartOrStop(const HostResource& audio_id,
@@ -218,9 +235,9 @@ void PPB_Audio_Proxy::OnMsgNotifyAudioStreamCreated(
   PP_Resource plugin_resource =
       PluginResourceTracker::GetInstance()->PluginResourceForHostResource(
           audio_id);
-  Audio* object = plugin_resource ?
-      PluginResource::GetAs<Audio>(plugin_resource) : NULL;
-  if (!object || result_code != PP_OK) {
+  ppapi::thunk::EnterResource<ppapi::thunk::PPB_Audio_API> enter(
+      plugin_resource, false);
+  if (enter.failed() || result_code != PP_OK) {
     // The caller may still have given us these handles in the failure case.
     // The easiest way to clean these up is to just put them in the objects
     // and then close them. This failure case is not performance critical.
@@ -229,7 +246,8 @@ void PPB_Audio_Proxy::OnMsgNotifyAudioStreamCreated(
     base::SharedMemory temp_mem(handle, false);
     return;
   }
-  object->SetStreamInfo(
+  Audio* audio = static_cast<Audio*>(enter.object());
+  audio->SetStreamInfo(
       handle, length, IPC::PlatformFileForTransitToPlatformFile(socket_handle));
 }
 
@@ -264,16 +282,14 @@ int32_t PPB_Audio_Proxy::GetAudioConnectedHandles(
     base::SharedMemoryHandle* foreign_shared_memory_handle,
     uint32_t* shared_memory_length) {
   // Get the trusted audio interface which will give us the handles.
-  const PPB_AudioTrusted* audio_trusted =
-      reinterpret_cast<const PPB_AudioTrusted*>(
-          dispatcher()->GetLocalInterface(PPB_AUDIO_TRUSTED_INTERFACE));
-  if (!audio_trusted)
+  ::ppapi::thunk::EnterResourceNoLock< ::ppapi::thunk::PPB_AudioTrusted_API>
+      trusted_audio(resource.host_resource(), false);
+  if (trusted_audio.failed())
     return PP_ERROR_NOINTERFACE;
 
   // Get the socket handle for signaling.
   int32_t socket_handle;
-  int32_t result = audio_trusted->GetSyncSocket(resource.host_resource(),
-                                                &socket_handle);
+  int32_t result = trusted_audio.object()->GetSyncSocket(&socket_handle);
   if (result != PP_OK)
     return result;
 
@@ -285,9 +301,8 @@ int32_t PPB_Audio_Proxy::GetAudioConnectedHandles(
 
   // Get the shared memory for the buffer.
   int shared_memory_handle;
-  result = audio_trusted->GetSharedMemory(resource.host_resource(),
-                                          &shared_memory_handle,
-                                          shared_memory_length);
+  result = trusted_audio.object()->GetSharedMemory(&shared_memory_handle,
+                                                   shared_memory_length);
   if (result != PP_OK)
     return result;
 
diff --git a/ppapi/proxy/ppb_audio_proxy.h b/ppapi/proxy/ppb_audio_proxy.h
index 6574ef7..e39a82d 100644
--- a/ppapi/proxy/ppb_audio_proxy.h
+++ b/ppapi/proxy/ppb_audio_proxy.h
@@ -5,6 +5,8 @@
 #ifndef PPAPI_PROXY_PPB_AUDIO_PROXY_H_
 #define PPAPI_PROXY_PPB_AUDIO_PROXY_H_
 
+#include <utility>
+
 #include "base/basictypes.h"
 #include "base/shared_memory.h"
 #include "base/sync_socket.h"
@@ -12,6 +14,8 @@
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_module.h"
 #include "ppapi/c/pp_resource.h"
+#include "ppapi/c/ppb_audio.h"
+#include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/proxy_non_thread_safe_ref_count.h"
@@ -30,6 +34,13 @@ class PPB_Audio_Proxy : public InterfaceProxy {
 
   static const Info* GetInfo();
 
+  // Creates an Audio object in the plugin process.
+  static PP_Resource CreateProxyResource(PP_Instance instance_id,
+                                         PP_Resource config_id,
+                                         PPB_Audio_Callback audio_callback,
+                                         void* user_data);
+
+
   const PPB_Audio* ppb_audio_target() const {
     return static_cast<const PPB_Audio*>(target_interface());
   }
@@ -40,7 +51,8 @@ class PPB_Audio_Proxy : public InterfaceProxy {
  private:
   // Plugin->renderer message handlers.
   void OnMsgCreate(PP_Instance instance_id,
-                   const HostResource& config_id,
+                   int32_t sample_rate,
+                   uint32_t sample_frame_count,
                    HostResource* result);
   void OnMsgStartOrStop(const HostResource& audio_id, bool play);
 
diff --git a/ppapi/proxy/ppb_char_set_proxy.cc b/ppapi/proxy/ppb_char_set_proxy.cc
index 5c9c7d0..5a0be2e 100644
--- a/ppapi/proxy/ppb_char_set_proxy.cc
+++ b/ppapi/proxy/ppb_char_set_proxy.cc
@@ -27,7 +27,7 @@ char* UTF16ToCharSet(PP_Instance /* instance */,
                      const char* output_char_set,
                      PP_CharSet_ConversionError on_error,
                      uint32_t* output_length) {
-  return pp::shared_impl::CharSetImpl::UTF16ToCharSet(
+  return ppapi::CharSetImpl::UTF16ToCharSet(
       GetCoreInterface(), utf16, utf16_len, output_char_set, on_error,
       output_length);
 }
@@ -37,7 +37,7 @@ uint16_t* CharSetToUTF16(PP_Instance /* instance */,
                          const char* input_char_set,
                          PP_CharSet_ConversionError on_error,
                          uint32_t* output_length) {
-  return pp::shared_impl::CharSetImpl::CharSetToUTF16(
+  return ppapi::CharSetImpl::CharSetToUTF16(
       GetCoreInterface(), input, input_len, input_char_set, on_error,
       output_length);
 }
diff --git a/ppapi/proxy/ppb_crypto_proxy.cc b/ppapi/proxy/ppb_crypto_proxy.cc
index 207b400..d900800 100644
--- a/ppapi/proxy/ppb_crypto_proxy.cc
+++ b/ppapi/proxy/ppb_crypto_proxy.cc
@@ -14,7 +14,7 @@ namespace proxy {
 namespace {
 
 const PPB_Crypto_Dev crypto_interface = {
-  &pp::shared_impl::CryptoImpl::GetRandomBytes
+  &ppapi::CryptoImpl::GetRandomBytes
 };
 
 InterfaceProxy* CreateCryptoProxy(Dispatcher* dispatcher,
diff --git a/ppapi/proxy/ppb_font_proxy.cc b/ppapi/proxy/ppb_font_proxy.cc
index 9d52fcc..ace9f76 100644
--- a/ppapi/proxy/ppb_font_proxy.cc
+++ b/ppapi/proxy/ppb_font_proxy.cc
@@ -14,7 +14,7 @@
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::thunk::PPB_ImageData_API;
-using pp::shared_impl::WebKitForwarding;
+using ppapi::WebKitForwarding;
 
 namespace pp {
 namespace proxy {
@@ -121,8 +121,8 @@ PP_Bool Font::DrawTextAt(PP_Resource pp_image_data,
                          const PP_Rect* clip,
                          PP_Bool image_data_is_opaque) {
   // Convert to an ImageData object.
-  ppapi::shared_impl::ResourceObjectBase* image_base =
-      ppapi::shared_impl::TrackerBase::Get()->GetResourceAPI(pp_image_data);
+  ppapi::ResourceObjectBase* image_base =
+      ppapi::TrackerBase::Get()->GetResourceAPI(pp_image_data);
   if (!image_base)
     return PP_FALSE;
   PPB_ImageData_API* image_api = image_base->GetAs<PPB_ImageData_API>();
diff --git a/ppapi/proxy/ppb_font_proxy.h b/ppapi/proxy/ppb_font_proxy.h
index 35b1c55..8fec581 100644
--- a/ppapi/proxy/ppb_font_proxy.h
+++ b/ppapi/proxy/ppb_font_proxy.h
@@ -73,7 +73,7 @@ class Font : public PluginResource,
 
   base::WaitableEvent webkit_event_;
 
-  scoped_ptr<pp::shared_impl::WebKitForwarding::Font> font_forwarding_;
+  scoped_ptr<ppapi::WebKitForwarding::Font> font_forwarding_;
 
   DISALLOW_COPY_AND_ASSIGN(Font);
 };
diff --git a/ppapi/proxy/ppb_image_data_proxy.h b/ppapi/proxy/ppb_image_data_proxy.h
index 71198bd..6bd97a5ad 100644
--- a/ppapi/proxy/ppb_image_data_proxy.h
+++ b/ppapi/proxy/ppb_image_data_proxy.h
@@ -47,7 +47,7 @@ class PPB_ImageData_Proxy : public InterfaceProxy {
 
 class ImageData : public PluginResource,
                   public ::ppapi::thunk::PPB_ImageData_API,
-                  public pp::shared_impl::ImageDataImpl {
+                  public ppapi::ImageDataImpl {
  public:
   ImageData(const HostResource& resource,
             const PP_ImageDataDesc& desc,
diff --git a/ppapi/proxy/ppb_url_util_proxy.cc b/ppapi/proxy/ppb_url_util_proxy.cc
index 17b36ea..b59ef3c 100644
--- a/ppapi/proxy/ppb_url_util_proxy.cc
+++ b/ppapi/proxy/ppb_url_util_proxy.cc
@@ -15,7 +15,7 @@
 namespace pp {
 namespace proxy {
 
-using pp::shared_impl::URLUtilImpl;
+using ppapi::URLUtilImpl;
 
 namespace {
 
diff --git a/ppapi/proxy/resource_creation_proxy.cc b/ppapi/proxy/resource_creation_proxy.cc
index 7346add..44d903d 100644
--- a/ppapi/proxy/resource_creation_proxy.cc
+++ b/ppapi/proxy/resource_creation_proxy.cc
@@ -9,18 +9,20 @@
 #include "ppapi/proxy/host_resource.h"
 #include "ppapi/proxy/interface_id.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
+#include "ppapi/c/trusted/ppb_image_data_trusted.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/proxy/ppb_graphics_2d_proxy.h"
+#include "ppapi/proxy/ppb_audio_config_proxy.h"
+#include "ppapi/proxy/ppb_audio_proxy.h"
 #include "ppapi/proxy/ppb_font_proxy.h"
+#include "ppapi/proxy/ppb_graphics_2d_proxy.h"
 #include "ppapi/proxy/ppb_image_data_proxy.h"
-#include "ppapi/c/trusted/ppb_image_data_trusted.h"
 #include "ppapi/shared_impl/font_impl.h"
 #include "ppapi/shared_impl/function_group_base.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_image_data_api.h"
 
-using ::ppapi::thunk::ResourceCreationAPI;
+using ppapi::thunk::ResourceCreationAPI;
 
 namespace pp {
 namespace proxy {
@@ -37,17 +39,36 @@ ResourceCreationProxy::AsResourceCreation() {
   return this;
 }
 
+PP_Resource ResourceCreationProxy::CreateAudio(
+    PP_Instance instance,
+    PP_Resource config_id,
+    PPB_Audio_Callback audio_callback,
+    void* user_data) {
+  return PPB_Audio_Proxy::CreateProxyResource(instance, config_id,
+                                              audio_callback, user_data);
+}
+
+PP_Resource ResourceCreationProxy::CreateAudioConfig(
+    PP_Instance instance,
+    PP_AudioSampleRate sample_rate,
+    uint32_t sample_frame_count) {
+  return PPB_AudioConfig_Proxy::CreateProxyResource(
+      instance, sample_rate, sample_frame_count);
+}
+
+PP_Resource ResourceCreationProxy::CreateAudioTrusted(PP_Instance instance) {
+  // Proxied plugins can't created trusted audio devices.
+  return 0;
+}
+
 PP_Resource ResourceCreationProxy::CreateFontObject(
     PP_Instance instance,
     const PP_FontDescription_Dev* description) {
-  if (!pp::shared_impl::FontImpl::IsPPFontDescriptionValid(*description))
+  if (!ppapi::FontImpl::IsPPFontDescriptionValid(*description))
     return 0;
 
-  // See the comment above Font's constructor for why we do this.
-  HostResource resource;
-  resource.SetHostResource(instance, 0);
-
-  linked_ptr<Font> object(new Font(resource, *description));
+  linked_ptr<Font> object(new Font(HostResource::MakeInstanceOnly(instance),
+                                   *description));
   return PluginResourceTracker::GetInstance()->AddResource(object);
 }
 
@@ -143,8 +164,8 @@ void ResourceCreationProxy::OnMsgCreateImageData(
   result->SetHostResource(instance, resource);
 
   // Get the description, it's just serialized as a string.
-  ppapi::thunk::EnterResource<ppapi::thunk::PPB_ImageData_API> enter_resource(
-      resource, false);
+  ppapi::thunk::EnterResourceNoLock<ppapi::thunk::PPB_ImageData_API>
+      enter_resource(resource, false);
   PP_ImageDataDesc desc;
   if (enter_resource.object()->Describe(&desc) == PP_TRUE) {
     image_data_desc->resize(sizeof(PP_ImageDataDesc));
diff --git a/ppapi/proxy/resource_creation_proxy.h b/ppapi/proxy/resource_creation_proxy.h
index 4cc1391..c0cae7f 100644
--- a/ppapi/proxy/resource_creation_proxy.h
+++ b/ppapi/proxy/resource_creation_proxy.h
@@ -21,7 +21,7 @@ namespace proxy {
 class HostResource;
 class Dispatcher;
 
-class ResourceCreationProxy : public ::ppapi::shared_impl::FunctionGroupBase,
+class ResourceCreationProxy : public ::ppapi::FunctionGroupBase,
                               public ::ppapi::thunk::ResourceCreationAPI,
                               public ::IPC::Channel::Listener,
                               public IPC::Message::Sender {
@@ -29,25 +29,37 @@ class ResourceCreationProxy : public ::ppapi::shared_impl::FunctionGroupBase,
   ResourceCreationProxy(Dispatcher* dispatcher);
   virtual ~ResourceCreationProxy();
 
-  virtual ::ppapi::thunk::ResourceCreationAPI* AsResourceCreation();
+  virtual ::ppapi::thunk::ResourceCreationAPI* AsResourceCreation() OVERRIDE;
 
   // ResourceCreationAPI (called in plugin).
+  virtual PP_Resource CreateAudio(PP_Instance instance,
+                                  PP_Resource config_id,
+                                  PPB_Audio_Callback audio_callback,
+                                  void* user_data) OVERRIDE;
+  virtual PP_Resource CreateAudioConfig(PP_Instance instance,
+                                        PP_AudioSampleRate sample_rate,
+                                        uint32_t sample_frame_count) OVERRIDE;
+  virtual PP_Resource CreateAudioTrusted(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateFontObject(
       PP_Instance instance,
-      const PP_FontDescription_Dev* description);
+      const PP_FontDescription_Dev* description) OVERRIDE;
   virtual PP_Resource CreateGraphics2D(PP_Instance pp_instance,
                                        const PP_Size& size,
-                                       PP_Bool is_always_opaque);
+                                       PP_Bool is_always_opaque) OVERRIDE;
   virtual PP_Resource CreateImageData(PP_Instance instance,
                                       PP_ImageDataFormat format,
                                       const PP_Size& size,
-                                      PP_Bool init_to_zero);
+                                      PP_Bool init_to_zero) OVERRIDE;
 
-  virtual bool Send(IPC::Message* msg);
-  virtual bool OnMessageReceived(const IPC::Message& msg);
+  virtual bool Send(IPC::Message* msg) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 
  private:
   // IPC message handlers (called in browser).
+  void OnMsgCreateAudio(PP_Instance instance,
+                        int32_t sample_rate,
+                        uint32_t sample_frame_count,
+                        HostResource* result);
   void OnMsgCreateGraphics2D(PP_Instance instance,
                              const PP_Size& size,
                              PP_Bool is_always_opaque,