Put code in //services/js in namespace js

services/js/js_app.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 "services/js/js_app.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "gin/converter.h"
 #include "gin/modules/module_registry.h"
 #include "gin/try_catch.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/edk/js/core.h"
 #include "mojo/edk/js/handle.h"
 #include "mojo/edk/js/support.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/js/js_app_bridge_module.h"
 #include "services/js/js_app_message_loop_observers.h"
 #include "services/js/js_app_shell.h"
 
-namespace mojo {
 namespace js {
 
 namespace {
 
 // If true then result is the value of value.property_name.
 bool GetValueProperty(v8::Isolate* isolate,
                       v8::Handle<v8::Value> value,
                       const std::string& property_name,
                       v8::Handle<v8::Value>* result) {
   if (!value->IsObject())
@@ skipping 41 matching lines @@
   v8::Local<v8::Value> connection_value =
     get_connection_method->Call(service_provider, 0, nullptr);
   return GetValueMojoHandle(
       isolate, connection_value, "messagePipeHandle", result);
 }
 
 } // namespace
 
 const char JSApp::kMainModuleName[] = "main";
 
-JSApp::JSApp(ShellPtr shell, URLResponsePtr response) : shell_(shell.Pass()) {
+JSApp::JSApp(mojo::ShellPtr shell, mojo::URLResponsePtr response)
+    : shell_(shell.Pass()) {
   v8::Isolate* isolate = isolate_holder_.isolate();
   message_loop_observers_.reset(new JSAppMessageLoopObservers(isolate));
 
   DCHECK(!response.is_null());
   std::string url(response->url);
   std::string source;
-  CHECK(common::BlockingCopyToString(response->body.Pass(), &source));
+  CHECK(mojo::common::BlockingCopyToString(response->body.Pass(), &source));
 
   runner_delegate_.AddBuiltinModule(AppBridge::kModuleName,
       base::Bind(&AppBridge::GetModule, base::Unretained(this)));
 
   shell_runner_.reset(new gin::ShellRunner(&runner_delegate_, isolate));
   gin::Runner::Scope scope(shell_runner_.get());
   shell_runner_->Run(source.c_str(), kMainModuleName);
 
   gin::ModuleRegistry* registry =
       gin::ModuleRegistry::From(shell_runner_->GetContextHolder()->context());
@@ skipping 27 matching lines @@
 }
 
 void JSApp::ConnectToApplication(const std::string& application_url,
                                  v8::Handle<v8::Value> service_provider) {
   gin::Runner::Scope scope(shell_runner_.get());
   v8::Isolate* isolate = isolate_holder_.isolate();
 
   mojo::Handle handle;
   if (GetConnectionMessagePipeHandle(isolate, service_provider, &handle) ||
       gin::ConvertFromV8(isolate, service_provider, &handle)) {
-    MessagePipeHandle message_pipe_handle(handle.value());
-    ScopedMessagePipeHandle scoped_handle(message_pipe_handle);
+    mojo::MessagePipeHandle message_pipe_handle(handle.value());
+    mojo::ScopedMessagePipeHandle scoped_handle(message_pipe_handle);
     shell_->ConnectToApplication(
-        application_url, MakeRequest<ServiceProvider>(scoped_handle.Pass()));
+        application_url,
+        mojo::MakeRequest<mojo::ServiceProvider>(scoped_handle.Pass()));
   }
 }
 
 void JSApp::CallAppInstanceMethod(
     const std::string& name, int argc, v8::Handle<v8::Value> argv[]) {
   v8::Isolate* isolate = isolate_holder_.isolate();
   v8::Local<v8::Object> app =
       v8::Local<v8::Object>::New(isolate, app_instance_);
 
   v8::Handle<v8::Function> app_method;
   GetValueMethod(isolate, app, name, &app_method);
   shell_runner_->Call(app_method, app, argc, argv);
 }
 
-void JSApp::Initialize(Array<String> app_args) {
+void JSApp::Initialize(mojo::Array<mojo::String> app_args) {
   gin::Runner::Scope scope(shell_runner_.get());
   v8::Isolate* isolate = isolate_holder_.isolate();
   v8::Handle<v8::Value> argv[] = {
     gin::ConvertToV8(isolate, app_args.To<std::vector<std::string>>()),
   };
   CallAppInstanceMethod("initialize", 1, argv);
 }
 
-void JSApp::AcceptConnection(const String& requestor_url,
-                             ServiceProviderPtr provider) {
+void JSApp::AcceptConnection(const mojo::String& requestor_url,
+                             mojo::ServiceProviderPtr provider) {
   gin::Runner::Scope scope(shell_runner_.get());
   v8::Isolate* isolate = isolate_holder_.isolate();
   v8::Handle<v8::Value> argv[] = {
     gin::ConvertToV8(isolate, requestor_url.To<std::string>()),
     gin::ConvertToV8(isolate, provider.PassMessagePipe().release()),
   };
   CallAppInstanceMethod("acceptConnection_", arraysize(argv), argv);
 }
 
 void JSApp::Quit() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&JSApp::QuitInternal, base::Unretained(this)));
 }
 
 void JSApp::QuitInternal() {
   shell_runner_.reset();
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 }  // namespace js
-}  // namespace mojo