Remove mojo:: part of mojo::shell:: nested namespace in //shell.

shell/android/android_handler.cc

 // Copyright 2014 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 "shell/android/android_handler.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/scoped_native_library.h"
 #include "jni/AndroidHandler_jni.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "shell/android/run_android_application_function.h"
 #include "shell/native_application_support.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ScopedJavaLocalRef;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::GetApplicationContext;
 
-namespace mojo {
 namespace shell {
 
 namespace {
 
 // This function loads the application library, sets the application context and
 // thunks and calls into the application MojoMain. To ensure that the thunks are
 // set correctly we keep it in the Mojo shell .so and pass the function pointer
 // to the helper libbootstrap.so.
 void RunAndroidApplication(JNIEnv* env,
                            jobject j_context,
                            const base::FilePath& app_path,
                            jint j_handle) {
-  InterfaceRequest<Application> application_request =
-      MakeRequest<Application>(MakeScopedHandle(MessagePipeHandle(j_handle)));
+  mojo::InterfaceRequest<mojo::Application> application_request =
+      mojo::MakeRequest<mojo::Application>(
+          mojo::MakeScopedHandle(mojo::MessagePipeHandle(j_handle)));
 
   // Load the library, so that we can set the application context there if
   // needed.
   // TODO(vtl): We'd use a ScopedNativeLibrary, but it doesn't have .get()!
   base::NativeLibrary app_library =
       LoadNativeApplication(app_path, NativeApplicationCleanup::DELETE);
   if (!app_library)
     return;
 
   // Set the application context if needed. Most applications will need to
@@ skipping 21 matching lines @@
 
 }  // namespace
 
 AndroidHandler::AndroidHandler() : content_handler_factory_(this) {
 }
 
 AndroidHandler::~AndroidHandler() {
 }
 
 void AndroidHandler::RunApplication(
-    InterfaceRequest<Application> application_request,
-    URLResponsePtr response) {
+    mojo::InterfaceRequest<mojo::Application> application_request,
+    mojo::URLResponsePtr response) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_archive_path =
       Java_AndroidHandler_getNewTempArchivePath(env, GetApplicationContext());
   base::FilePath archive_path(
       ConvertJavaStringToUTF8(env, j_archive_path.obj()));
 
-  common::BlockingCopyToFile(response->body.Pass(), archive_path);
+  mojo::common::BlockingCopyToFile(response->body.Pass(), archive_path);
   RunAndroidApplicationFn run_android_application_fn = &RunAndroidApplication;
   Java_AndroidHandler_bootstrap(
       env, GetApplicationContext(), j_archive_path.obj(),
       application_request.PassMessagePipe().release().value(),
       reinterpret_cast<jlong>(run_android_application_fn));
 }
 
-void AndroidHandler::Initialize(ApplicationImpl* app) {
+void AndroidHandler::Initialize(mojo::ApplicationImpl* app) {
 }
 
 bool AndroidHandler::ConfigureIncomingConnection(
-    ApplicationConnection* connection) {
+    mojo::ApplicationConnection* connection) {
   connection->AddService(&content_handler_factory_);
   connection->AddService(&intent_receiver_manager_factory_);
   return true;
 }
 
 bool RegisterAndroidHandlerJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace shell
-}  // namespace mojo