Convert the pp::proxy namespace to the ppapi::proxy namespace.

ppapi/proxy/plugin_dispatcher.cc

 // 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.
 
 #include "ppapi/proxy/plugin_dispatcher.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 #include "ppapi/proxy/ppp_class_proxy.h"
 #include "ppapi/proxy/resource_creation_proxy.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/tracker_base.h"
 
 #if defined(OS_POSIX)
 #include "base/eintr_wrapper.h"
 #include "ipc/ipc_channel_posix.h"
 #endif
 
-using ppapi::Resource;
-
-namespace pp {
+namespace ppapi {
 namespace proxy {
 
 namespace {
 
 typedef std::map<PP_Instance, PluginDispatcher*> InstanceToDispatcherMap;
 InstanceToDispatcherMap* g_instance_to_dispatcher = NULL;
 
 }  // namespace
 
 PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
                                    GetInterfaceFunc get_interface)
     : Dispatcher(remote_process_handle, get_interface),
       plugin_delegate_(NULL),
       received_preferences_(false),
       plugin_dispatcher_id_(0) {
   SetSerializationRules(new PluginVarSerializationRules);
 
   // As a plugin, we always support the PPP_Class interface. There's no
   // 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::TrackerBase::Init(
-      &PluginResourceTracker::GetTrackerBaseInstance);
+  TrackerBase::Init(&PluginResourceTracker::GetTrackerBaseInstance);
 }
 
 PluginDispatcher::~PluginDispatcher() {
   if (plugin_delegate_)
     plugin_delegate_->Unregister(plugin_dispatcher_id_);
 }
 
 // static
 PluginDispatcher* PluginDispatcher::GetForInstance(PP_Instance instance) {
   if (!g_instance_to_dispatcher)
@@ skipping 155 matching lines @@
 void PluginDispatcher::PostToWebKitThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   return plugin_delegate_->PostToWebKitThread(from_here, task);
 }
 
 bool PluginDispatcher::SendToBrowser(IPC::Message* msg) {
   return plugin_delegate_->SendToBrowser(msg);
 }
 
-ppapi::WebKitForwarding* PluginDispatcher::GetWebKitForwarding() {
+WebKitForwarding* PluginDispatcher::GetWebKitForwarding() {
   return plugin_delegate_->GetWebKitForwarding();
 }
 
-::ppapi::FunctionGroupBase* PluginDispatcher::GetFunctionAPI(
-    pp::proxy::InterfaceID id) {
-  scoped_ptr< ::ppapi::FunctionGroupBase >& proxy = function_proxies_[id];
+FunctionGroupBase* PluginDispatcher::GetFunctionAPI(InterfaceID id) {
+  scoped_ptr<FunctionGroupBase >& proxy = function_proxies_[id];
 
   if (proxy.get())
     return proxy.get();
 
   if (id == INTERFACE_ID_PPB_CHAR_SET)
     proxy.reset(new PPB_CharSet_Proxy(this, NULL));
   else if(id == INTERFACE_ID_PPB_CURSORCONTROL)
     proxy.reset(new PPB_CursorControl_Proxy(this, NULL));
   else if (id == INTERFACE_ID_PPB_FONT)
     proxy.reset(new PPB_Font_Proxy(this, NULL));
@@ skipping 42 matching lines @@
 
   // Query the plugin & cache the result.
   const void* interface_functions = GetLocalInterface(interface_name.c_str());
   if (!interface_functions)
     return;
   target_proxies_[info->id].reset(
       info->create_proxy(this, interface_functions));
   *result = true;
 }
 
-void PluginDispatcher::OnMsgSetPreferences(const ::ppapi::Preferences& prefs) {
+void PluginDispatcher::OnMsgSetPreferences(const Preferences& prefs) {
   // The renderer may send us preferences more than once (currently this
   // happens every time a new plugin instance is created). Since we don't have
   // a way to signal to the plugin that the preferences have changed, changing
   // the default fonts and such in the middle of a running plugin could be
   // confusing to it. As a result, we never allow the preferences to be changed
   // once they're set. The user will have to restart to get new font prefs
   // propogated to plugins.
   if (!received_preferences_) {
     received_preferences_ = true;
     preferences_ = prefs;
   }
 }
 
 }  // namespace proxy
-}  // namespace pp
+}  // namespace ppapi