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

ppapi/proxy/enter_proxy.h

 // 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.
 
 #ifndef PPAPI_PROXY_ENTER_PROXY_H_
 #define PPAPI_PROXY_ENTER_PROXY_H_
 
 #include "base/logging.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/thunk/enter.h"
 
-namespace pp {
+namespace ppapi {
 namespace proxy {
 
 // Wrapper around EnterResourceNoLock that takes a host resource. This is used
 // when handling messages in the plugin from the host and we need to convert to
 // an object in the plugin side corresponding to that.
 //
 // This never locks since we assume the host Resource is coming from IPC, and
 // never logs errors since we assume the host is doing reasonable things.
 template<typename ResourceT>
 class EnterPluginFromHostResource
-    : public ::ppapi::thunk::EnterResourceNoLock<ResourceT> {
+    : public thunk::EnterResourceNoLock<ResourceT> {
  public:
-  EnterPluginFromHostResource(const ppapi::HostResource& host_resource)
-      : ::ppapi::thunk::EnterResourceNoLock<ResourceT>(
+  EnterPluginFromHostResource(const HostResource& host_resource)
+      : thunk::EnterResourceNoLock<ResourceT>(
             PluginResourceTracker::GetInstance()->PluginResourceForHostResource(
                 host_resource),
             false) {
     // Validate that we're in the plugin rather than the host. Otherwise this
     // object will do the wrong thing. In the plugin, the instance should have
     // a corresponding plugin dispatcher (assuming the resource is valid).
     DCHECK(this->failed() ||
            PluginDispatcher::GetForInstance(host_resource.instance()));
   }
 };
 
 template<typename ResourceT>
 class EnterHostFromHostResource
-    : public ::ppapi::thunk::EnterResourceNoLock<ResourceT> {
+    : public thunk::EnterResourceNoLock<ResourceT> {
  public:
-  EnterHostFromHostResource(const ppapi::HostResource& host_resource)
-      : ::ppapi::thunk::EnterResourceNoLock<ResourceT>(
+  EnterHostFromHostResource(const HostResource& host_resource)
+      : thunk::EnterResourceNoLock<ResourceT>(
             host_resource.host_resource(), false) {
     // Validate that we're in the host rather than the plugin. Otherwise this
     // object will do the wrong thing. In the host, the instance should have
     // a corresponding host disptacher (assuming the resource is valid).
     DCHECK(this->failed() ||
            HostDispatcher::GetForInstance(host_resource.instance()));
   }
 };
 
 // Enters a resource and forces a completion callback to be issued.
@@ skipping 27 matching lines @@
 //     Send(new FooMsg_FooComplete(..., result, res));
 //   }
 template<typename ResourceT>
 class EnterHostFromHostResourceForceCallback
     : public EnterHostFromHostResource<ResourceT> {
  public:
   // For callbacks that take no parameters except the "int32_t result". Most
   // implementations will use the 1-extra-argument constructor below.
   template<class CallbackFactory, typename Method>
   EnterHostFromHostResourceForceCallback(
-      const ppapi::HostResource& host_resource,
+      const HostResource& host_resource,
       CallbackFactory& factory,
       Method method)
       : EnterHostFromHostResource<ResourceT>(host_resource),
         needs_running_(true),
         callback_(factory.NewOptionalCallback(method)) {
     if (this->failed())
       RunCallback(PP_ERROR_BADRESOURCE);
   }
 
   // For callbacks that take an extra parameter as a closure.
   template<class CallbackFactory, typename Method, typename A>
   EnterHostFromHostResourceForceCallback(
-      const ppapi::HostResource& host_resource,
+      const HostResource& host_resource,
       CallbackFactory& factory,
       Method method,
       const A& a)
       : EnterHostFromHostResource<ResourceT>(host_resource),
         needs_running_(true),
         callback_(factory.NewOptionalCallback(method, a)) {
     if (this->failed())
       RunCallback(PP_ERROR_BADRESOURCE);
   }
 
@@ skipping 21 matching lines @@
     DCHECK(needs_running_);
     needs_running_ = false;
     callback_.Run(result);
   }
 
   bool needs_running_;
   pp::CompletionCallback callback_;
 };
 
 }  // namespace proxy
-}  // namespace pp
+}  // namespace ppapi
 
 #endif  // PPAPI_PROXY_ENTER_PROXY_H_