Remove extraneous namespaces

mojo/examples/window_manager/window_manager.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/basictypes.h"
 #include "base/bind.h"
 #include "mojo/examples/keyboard/keyboard.mojom.h"
 #include "mojo/examples/window_manager/debug_panel.h"
 #include "mojo/examples/window_manager/window_manager.mojom.h"
 #include "mojo/public/cpp/application/application_connection.h"
@@ skipping 44 matching lines @@
   // Overridden from IWindowManager:
   virtual void CloseWindow(Id node_id) OVERRIDE;
   virtual void ShowKeyboard(Id view_id, RectPtr bounds) OVERRIDE;
   virtual void HideKeyboard(Id view_id) OVERRIDE;
 
   WindowManager* window_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerConnection);
 };
 
-class NavigatorHost : public InterfaceImpl<navigation::NavigatorHost> {
+class NavigatorHostImpl : public InterfaceImpl<NavigatorHost> {
  public:
-  explicit NavigatorHost(WindowManager* window_manager)
+  explicit NavigatorHostImpl(WindowManager* window_manager)
       : window_manager_(window_manager) {}
-  virtual ~NavigatorHost() {
+  virtual ~NavigatorHostImpl() {
   }
 
  private:
   virtual void DidNavigateLocally(uint32 source_node_id,
                                   const mojo::String& url) OVERRIDE;
   virtual void RequestNavigate(
       uint32 source_node_id,
-      navigation::Target target,
-      navigation::NavigationDetailsPtr nav_details) OVERRIDE;
+      Target target,
+      NavigationDetailsPtr nav_details) OVERRIDE;
   WindowManager* window_manager_;
 
-  DISALLOW_COPY_AND_ASSIGN(NavigatorHost);
+  DISALLOW_COPY_AND_ASSIGN(NavigatorHostImpl);
 };
 
 class KeyboardManager : public KeyboardClient,
                         public NodeObserver {
  public:
   KeyboardManager() : view_manager_(NULL), node_(NULL) {
   }
   virtual ~KeyboardManager() {
     if (node_)
       node_->parent()->RemoveObserver(this);
@@ skipping 155 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(RootLayoutManager);
 };
 
 class WindowManager
     : public ApplicationDelegate,
       public DebugPanel::Delegate,
       public ViewManagerDelegate,
       public WindowManagerDelegate,
       public InterfaceFactoryWithContext<WindowManagerConnection,
                                          WindowManager>,
-      public InterfaceFactoryWithContext<NavigatorHost, WindowManager> {
+      public InterfaceFactoryWithContext<NavigatorHostImpl, WindowManager> {
  public:
   WindowManager()
       : InterfaceFactoryWithContext<WindowManagerConnection, WindowManager>(
             this),
-        InterfaceFactoryWithContext<NavigatorHost, WindowManager>(this),
+        InterfaceFactoryWithContext<NavigatorHostImpl, WindowManager>(this),
         launcher_ui_(NULL),
         view_manager_(NULL),
         view_manager_client_factory_(this),
         app_(NULL) {}
 
   virtual ~WindowManager() {}
 
   void CloseWindow(Id node_id) {
     Node* node = view_manager_->GetNodeById(node_id);
     DCHECK(node);
@@ skipping 35 matching lines @@
   }
 
   // Overridden from DebugPanel::Delegate:
   virtual void CloseTopWindow() OVERRIDE {
     if (!windows_.empty())
       CloseWindow(windows_.back()->id());
   }
 
   virtual void RequestNavigate(
     uint32 source_node_id,
-    navigation::Target target,
-    navigation::NavigationDetailsPtr nav_details) OVERRIDE {
+    Target target,
+    NavigationDetailsPtr nav_details) OVERRIDE {
     launcher_->Launch(nav_details->url,
                       base::Bind(&WindowManager::OnLaunch,
                                  base::Unretained(this),
                                  source_node_id,
                                  target));
   }
 
  private:
   // Overridden from ApplicationDelegate:
   virtual void Initialize(ApplicationImpl* app) MOJO_OVERRIDE {
     app_ = app;
     app->ConnectToService("mojo:mojo_launcher", &launcher_);
     views_init_.reset(new ViewsInit);
   }
 
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
       MOJO_OVERRIDE {
     connection->AddService<IWindowManager>(this);
-    connection->AddService<navigation::NavigatorHost>(this);
+    connection->AddService<mojo::NavigatorHost>(this);
     connection->AddService(&view_manager_client_factory_);
     return true;
   }
 
   // Overridden from ViewManagerDelegate:
   virtual void OnRootAdded(ViewManager* view_manager, Node* root) OVERRIDE {
     DCHECK(!view_manager_);
     view_manager_ = view_manager;
     view_manager_->SetWindowManagerDelegate(this);
 
@@ skipping 18 matching lines @@
   }
   virtual void OnViewManagerDisconnected(ViewManager* view_manager) OVERRIDE {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // Overridden from WindowManagerDelegate:
   virtual void Embed(const String& url) OVERRIDE {
     CreateWindow(url,
-                 navigation::NavigationDetailsPtr().Pass(),
-                 navigation::ResponseDetailsPtr().Pass());
+                 NavigationDetailsPtr().Pass(),
+                 ResponseDetailsPtr().Pass());
   }
   virtual void DispatchEvent(View* target, EventPtr event) OVERRIDE {
     // TODO(beng): More sophisticated focus handling than this is required!
     if (event->action == EVENT_TYPE_MOUSE_PRESSED &&
         !IsDescendantOfKeyboard(target)) {
       target->node()->SetFocus();
     }
     view_manager_->DispatchEvent(target, event.Pass());
   }
 
   void OnLaunch(
       uint32 source_node_id,
-      navigation::Target requested_target,
+      Target requested_target,
       const mojo::String& handler_url,
       const mojo::String& view_url,
-      navigation::ResponseDetailsPtr response) {
-    navigation::NavigationDetailsPtr nav_details(
-        navigation::NavigationDetails::New());
+      ResponseDetailsPtr response) {
+    NavigationDetailsPtr nav_details(NavigationDetails::New());
     nav_details->url = view_url;
 
-    navigation::Target target = debug_panel_->navigation_target();
-    if (target == navigation::TARGET_DEFAULT) {
-      if (requested_target != navigation::TARGET_DEFAULT) {
+    Target target = debug_panel_->navigation_target();
+    if (target == TARGET_DEFAULT) {
+      if (requested_target != TARGET_DEFAULT) {
         target = requested_target;
       } else {
         // TODO(aa): Should be TARGET_NEW_NODE if source origin and dest origin
         // are different?
-        target = navigation::TARGET_SOURCE_NODE;
+        target = TARGET_SOURCE_NODE;
       }
     }
 
     Node* dest_node = NULL;
-    if (target == navigation::TARGET_SOURCE_NODE) {
+    if (target == TARGET_SOURCE_NODE) {
       Node* source_node = view_manager_->GetNodeById(source_node_id);
       bool app_initiated = std::find(windows_.begin(), windows_.end(),
                                      source_node) != windows_.end();
       if (app_initiated)
         dest_node = source_node;
       else if (!windows_.empty())
         dest_node = windows_.back();
     }
 
     if (dest_node)
       Embed(dest_node, handler_url, nav_details.Pass(), response.Pass());
     else
       CreateWindow(handler_url, nav_details.Pass(), response.Pass());
   }
 
   // TODO(beng): proper layout manager!!
   Id CreateLauncherUI() {
-    navigation::NavigationDetailsPtr nav_details;
-    navigation::ResponseDetailsPtr response;
+    NavigationDetailsPtr nav_details;
+    ResponseDetailsPtr response;
     Node* node = view_manager_->GetNodeById(content_node_id_);
     gfx::Rect bounds = node->bounds();
     bounds.Inset(kBorderInset, kBorderInset);
     bounds.set_height(kTextfieldHeight);
     launcher_ui_ = CreateChild(content_node_id_, "mojo:mojo_browser", bounds,
                                nav_details.Pass(), response.Pass());
     return launcher_ui_->id();
   }
 
   void CreateWindow(const std::string& handler_url,
-                    navigation::NavigationDetailsPtr nav_details,
-                    navigation::ResponseDetailsPtr response) {
+                    NavigationDetailsPtr nav_details,
+                    ResponseDetailsPtr response) {
     Node* node = view_manager_->GetNodeById(content_node_id_);
     gfx::Rect bounds(kBorderInset,
                      2 * kBorderInset + kTextfieldHeight,
                      node->bounds().width() - 3 * kBorderInset -
                          kControlPanelWidth,
                      node->bounds().height() -
                          (3 * kBorderInset + kTextfieldHeight));
     if (!windows_.empty()) {
       gfx::Point position = windows_.back()->bounds().origin();
       position.Offset(35, 35);
       bounds.set_origin(position);
     }
     windows_.push_back(CreateChild(content_node_id_, handler_url, bounds,
                                    nav_details.Pass(), response.Pass()));
   }
 
   Node* CreateChild(Id parent_id,
                     const std::string& url,
                     const gfx::Rect& bounds,
-                    navigation::NavigationDetailsPtr nav_details,
-                    navigation::ResponseDetailsPtr response) {
+                    NavigationDetailsPtr nav_details,
+                    ResponseDetailsPtr response) {
     Node* node = view_manager_->GetNodeById(parent_id);
     Node* embedded = Node::Create(view_manager_);
     node->AddChild(embedded);
     embedded->SetBounds(bounds);
     Embed(embedded, url, nav_details.Pass(), response.Pass());
     embedded->SetFocus();
     return embedded;
   }
 
   void Embed(Node* node, const std::string& app_url,
-             navigation::NavigationDetailsPtr nav_details,
-             navigation::ResponseDetailsPtr response) {
+             NavigationDetailsPtr nav_details,
+             ResponseDetailsPtr response) {
     node->Embed(app_url);
     if (nav_details) {
-      navigation::NavigatorPtr navigator;
+      NavigatorPtr navigator;
       app_->ConnectToService(app_url, &navigator);
       navigator->Navigate(node->id(), nav_details.Pass(), response.Pass());
     }
   }
 
   bool IsDescendantOfKeyboard(View* target) {
     return keyboard_manager_.get() &&
         keyboard_manager_->node()->Contains(target->node());
   }
 
@@ skipping 10 matching lines @@
                      root->bounds().height() - kBorderInset * 3 -
                          kTextfieldHeight);
     node->SetBounds(bounds);
 
     debug_panel_ = new DebugPanel(this, node);
     return node->id();
   }
 
   scoped_ptr<ViewsInit> views_init_;
   DebugPanel* debug_panel_;
-  launcher::LauncherPtr launcher_;
+  LauncherPtr launcher_;
   Node* launcher_ui_;
   std::vector<Node*> windows_;
   ViewManager* view_manager_;
   ViewManagerClientFactory view_manager_client_factory_;
   scoped_ptr<RootLayoutManager> root_layout_manager_;
 
   // Id of the node most content is added to. The keyboard is NOT added here.
   Id content_node_id_;
 
   scoped_ptr<KeyboardManager> keyboard_manager_;
   ApplicationImpl* app_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManager);
 };
 
 void WindowManagerConnection::CloseWindow(Id node_id) {
   window_manager_->CloseWindow(node_id);
 }
 
 void WindowManagerConnection::ShowKeyboard(Id view_id, RectPtr bounds) {
   window_manager_->ShowKeyboard(view_id, bounds.To<gfx::Rect>());
 }
 
 void WindowManagerConnection::HideKeyboard(Id node_id) {
   window_manager_->HideKeyboard(node_id);
 }
 
-void NavigatorHost::DidNavigateLocally(uint32 source_node_id,
-                                       const mojo::String& url) {
+void NavigatorHostImpl::DidNavigateLocally(uint32 source_node_id,
+                                           const mojo::String& url) {
   window_manager_->DidNavigateLocally(source_node_id, url);
 }
 
-void NavigatorHost::RequestNavigate(
+void NavigatorHostImpl::RequestNavigate(
     uint32 source_node_id,
-    navigation::Target target,
-    navigation::NavigationDetailsPtr nav_details) {
+    Target target,
+    NavigationDetailsPtr nav_details) {
   window_manager_->RequestNavigate(source_node_id, target, nav_details.Pass());
 }
 
 }  // namespace examples
 
 // static
 ApplicationDelegate* ApplicationDelegate::Create() {
   return new examples::WindowManager;
 }
 
 }  // namespace mojo