Remove extraneous namespaces

mojo/services/launcher/launcher.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 "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/interface_factory_with_context.h"
 #include "mojo/services/public/cpp/view_manager/types.h"
 #include "mojo/services/public/interfaces/launcher/launcher.mojom.h"
 #include "mojo/services/public/interfaces/network/network_service.mojom.h"
 #include "mojo/services/public/interfaces/network/url_loader.mojom.h"
 #include "url/gurl.h"
 
 namespace mojo {
-namespace launcher {
 
 namespace {
 
 typedef mojo::Callback<void(String handler_url, String view_url,
-    navigation::ResponseDetailsPtr response)> LaunchCallback;
+    ResponseDetailsPtr response)> LaunchCallback;
 
 }
 
 class LauncherApp;
 
 class LauncherConnection : public InterfaceImpl<Launcher> {
  public:
   explicit LauncherConnection(LauncherApp* app) : app_(app) {}
   virtual ~LauncherConnection() {}
 
@@ skipping 91 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LauncherApp);
 };
 
 void LauncherConnection::Launch(const String& url_string,
                                 const LaunchCallback& callback) {
   GURL url(url_string.To<std::string>());
 
   // For Mojo URLs, the handler can always be found at the origin.
   // TODO(aa): Return error for invalid URL?
   if (url.is_valid() && url.SchemeIs("mojo")) {
-    callback.Run(url.GetOrigin().spec(), url_string,
-                 navigation::ResponseDetailsPtr());
+    callback.Run(url.GetOrigin().spec(), url_string, ResponseDetailsPtr());
     return;
   }
   new LaunchInstance(app_, callback, url_string);
 }
 
 LaunchInstance::LaunchInstance(LauncherApp* app,
                                const LaunchCallback& callback,
                                const String& url)
     : app_(app),
       destroy_scheduled_(false),
       callback_(callback) {
   URLRequestPtr request(URLRequest::New());
   request->url = url;
   request->method = "GET";
   request->auto_follow_redirects = true;
 
   url_loader_ = app_->CreateURLLoader();
   url_loader_->Start(request.Pass(),
                      base::Bind(&LaunchInstance::OnReceivedResponse,
                                 base::Unretained(this)));
 }
 
 void LaunchInstance::OnReceivedResponse(URLResponsePtr response) {
   if (!response->error) {
     std::string content_type = GetContentType(response->headers);
     std::string handler_url = app_->GetHandlerForContentType(content_type);
     if (handler_url.empty()) {
       DLOG(WARNING) << "No handler for content type: " << content_type;
     } else {
-      navigation::ResponseDetailsPtr nav_response(
-          navigation::ResponseDetails::New());
+      ResponseDetailsPtr nav_response(ResponseDetails::New());
       nav_response->loader = url_loader_.Pass();
       nav_response->response = response.Pass();
       String response_url = nav_response->response->url;
       callback_.Run(handler_url, response_url, nav_response.Pass());
     }
   }
   ScheduleDestroy();
 }
 
-}  // namespace launcher
-
 // static
 ApplicationDelegate* ApplicationDelegate::Create() {
-  return new launcher::LauncherApp;
+  return new LauncherApp;
 }
 
 }  // namespace mojo