Put code in //services/window_manager in namespace window_manager

services/window_manager/window_manager_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/window_manager/window_manager_app.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 #include "mojo/services/public/cpp/view_manager/view_manager.h"
 #include "services/window_manager/focus_controller.h"
 #include "services/window_manager/focus_rules.h"
 #include "services/window_manager/view_event_dispatcher.h"
 #include "services/window_manager/view_target.h"
 #include "services/window_manager/view_targeter.h"
 #include "services/window_manager/window_manager_delegate.h"
 #include "ui/base/hit_test.h"
 
-namespace mojo {
+using mojo::ApplicationConnection;
+using mojo::Id;
+using mojo::ServiceProvider;
+using mojo::View;
+using mojo::WindowManager;
+
+namespace window_manager {
 
 namespace {
 
 Id GetIdForView(View* view) {
   return view ? view->id() : 0;
 }
 
 }  // namespace
 
 // Used for calls to Embed() that occur before we've connected to the
 // ViewManager.
 struct WindowManagerApp::PendingEmbed {
-  String url;
-  InterfaceRequest<mojo::ServiceProvider> service_provider;
+  mojo::String url;
+  mojo::InterfaceRequest<ServiceProvider> service_provider;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, public:
 
 WindowManagerApp::WindowManagerApp(
     ViewManagerDelegate* view_manager_delegate,
     WindowManagerDelegate* window_manager_delegate)
     : shell_(nullptr),
       native_viewport_event_dispatcher_factory_(this),
@@ skipping 35 matching lines @@
 void WindowManagerApp::ActivateWindow(Id view_id) {
   View* view = view_manager_->GetViewById(view_id);
   DCHECK(view);
   focus_controller_->ActivateView(view);
 }
 
 bool WindowManagerApp::IsReady() const {
   return view_manager_ && root_;
 }
 
-void WindowManagerApp::InitFocus(scoped_ptr<mojo::FocusRules> rules) {
-  focus_controller_.reset(new mojo::FocusController(rules.Pass()));
+void WindowManagerApp::InitFocus(scoped_ptr<FocusRules> rules) {
+  focus_controller_.reset(new FocusController(rules.Pass()));
   focus_controller_->AddObserver(this);
 
   DCHECK(root_);
   SetFocusController(root_, focus_controller_.get());
 }
 
 void WindowManagerApp::Embed(
-    const String& url,
-    InterfaceRequest<ServiceProvider> service_provider) {
+    const mojo::String& url,
+    mojo::InterfaceRequest<ServiceProvider> service_provider) {
   if (view_manager_) {
     window_manager_delegate_->Embed(url, service_provider.Pass());
     return;
   }
   scoped_ptr<PendingEmbed> pending_embed(new PendingEmbed);
   pending_embed->url = url;
   pending_embed->service_provider = service_provider.Pass();
   pending_embeds_.push_back(pending_embed.release());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ApplicationDelegate implementation:
 
-void WindowManagerApp::Initialize(ApplicationImpl* impl) {
+void WindowManagerApp::Initialize(mojo::ApplicationImpl* impl) {
   shell_ = impl->shell();
   LaunchViewManager(impl);
 }
 
 bool WindowManagerApp::ConfigureIncomingConnection(
     ApplicationConnection* connection) {
   connection->AddService(static_cast<InterfaceFactory<WindowManager>*>(this));
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ViewManagerDelegate implementation:
 
-void WindowManagerApp::OnEmbed(ViewManager* view_manager,
+void WindowManagerApp::OnEmbed(mojo::ViewManager* view_manager,
                                View* root,
-                               ServiceProviderImpl* exported_services,
+                               mojo::ServiceProviderImpl* exported_services,
                                scoped_ptr<ServiceProvider> imported_services) {
   DCHECK(!view_manager_ && !root_);
   view_manager_ = view_manager;
   root_ = root;
 
-  view_event_dispatcher_.reset(new ViewEventDispatcher());
+  view_event_dispatcher_.reset(new ViewEventDispatcher);
 
   RegisterSubtree(root_);
 
   // TODO(erg): Also move the capture client over.
   //
   // capture_client_.reset(
   //     new wm::ScopedCaptureClient(window_tree_host_->window()));
 
   if (wrapped_view_manager_delegate_) {
     wrapped_view_manager_delegate_->OnEmbed(
         view_manager, root, exported_services, imported_services.Pass());
   }
 
   for (PendingEmbed* pending_embed : pending_embeds_)
     Embed(pending_embed->url, pending_embed->service_provider.Pass());
   pending_embeds_.clear();
 }
 
 void WindowManagerApp::OnViewManagerDisconnected(
-    ViewManager* view_manager) {
+    mojo::ViewManager* view_manager) {
   DCHECK_EQ(view_manager_, view_manager);
   if (wrapped_view_manager_delegate_)
     wrapped_view_manager_delegate_->OnViewManagerDisconnected(view_manager);
   view_manager_ = nullptr;
   base::MessageLoop::current()->Quit();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ViewObserver implementation:
 
@@ skipping 36 matching lines @@
     return;
 
   View* view = static_cast<ViewTarget*>(event->target())->view();
   if (!view)
     return;
 
   if (focus_controller_)
     focus_controller_->OnEvent(event);
 
   window_manager_client_->DispatchInputEventToView(view->id(),
-                                                   Event::From(*event));
+                                                   mojo::Event::From(*event));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, mojo::FocusControllerObserver implementation:
 
 void WindowManagerApp::OnViewFocused(View* gained_focus,
                                      View* lost_focus) {
   for (Connections::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     (*it)->NotifyViewFocused(GetIdForView(gained_focus),
@@ skipping 44 matching lines @@
   if (it == registered_view_id_set_.end()) {
     // Because we unregister in OnViewDestroying() we can still get a subsequent
     // OnTreeChanged for the same view. Ignore this one.
     return;
   }
   view->RemoveObserver(this);
   DCHECK(it != registered_view_id_set_.end());
   registered_view_id_set_.erase(it);
 }
 
-void WindowManagerApp::DispatchInputEventToView(View* view, EventPtr event) {
+void WindowManagerApp::DispatchInputEventToView(View* view,
+                                                mojo::EventPtr event) {
   window_manager_client_->DispatchInputEventToView(view->id(), event.Pass());
 }
 
 void WindowManagerApp::SetViewportSize(const gfx::Size& size) {
-  window_manager_client_->SetViewportSize(Size::From(size));
+  window_manager_client_->SetViewportSize(mojo::Size::From(size));
 }
 
-void WindowManagerApp::LaunchViewManager(ApplicationImpl* app) {
+void WindowManagerApp::LaunchViewManager(mojo::ApplicationImpl* app) {
   // TODO(sky): figure out logic if this connection goes away.
   view_manager_client_factory_.reset(
-      new ViewManagerClientFactory(shell_, this));
+      new mojo::ViewManagerClientFactory(shell_, this));
 
-  MessagePipe pipe;
+  mojo::MessagePipe pipe;
   ApplicationConnection* view_manager_app =
       app->ConnectToApplication("mojo:view_manager");
   ServiceProvider* view_manager_service_provider =
       view_manager_app->GetServiceProvider();
-  view_manager_service_provider->ConnectToService(ViewManagerService::Name_,
-                                                  pipe.handle1.Pass());
-  view_manager_client_ = ViewManagerClientFactory::WeakBindViewManagerToPipe(
-                             pipe.handle0.Pass(), shell_, this).Pass();
+  view_manager_service_provider->ConnectToService(
+      mojo::ViewManagerService::Name_, pipe.handle1.Pass());
+  view_manager_client_ =
+      mojo::ViewManagerClientFactory::WeakBindViewManagerToPipe(
+          pipe.handle0.Pass(), shell_, this).Pass();
 
   view_manager_app->AddService(&native_viewport_event_dispatcher_factory_);
   view_manager_app->AddService(
       static_cast<InterfaceFactory<WindowManagerInternal>*>(this));
 
   view_manager_app->ConnectToService(&window_manager_client_);
 }
 
-void WindowManagerApp::Create(ApplicationConnection* connection,
-                              InterfaceRequest<WindowManagerInternal> request) {
+void WindowManagerApp::Create(
+    ApplicationConnection* connection,
+    mojo::InterfaceRequest<WindowManagerInternal> request) {
   if (wm_internal_binding_.get()) {
     VLOG(1) <<
         "WindowManager allows only one WindowManagerInternal connection.";
     return;
   }
   wm_internal_binding_.reset(
-      new Binding<WindowManagerInternal>(this, request.Pass()));
+      new mojo::Binding<WindowManagerInternal>(this, request.Pass()));
 }
 
 void WindowManagerApp::Create(ApplicationConnection* connection,
-                              InterfaceRequest<WindowManager> request) {
+                              mojo::InterfaceRequest<WindowManager> request) {
   WindowManagerImpl* wm = new WindowManagerImpl(this, false);
   wm->Bind(request.PassMessagePipe());
   // WindowManagerImpl is deleted when the connection has an error, or from our
   // destructor.
 }
 
 void WindowManagerApp::CreateWindowManagerForViewManagerClient(
     uint16_t connection_id,
-    ScopedMessagePipeHandle window_manager_pipe) {
+    mojo::ScopedMessagePipeHandle window_manager_pipe) {
   WindowManagerImpl* wm = new WindowManagerImpl(this, true);
   wm->Bind(window_manager_pipe.Pass());
   // WindowManagerImpl is deleted when the connection has an error, or from our
   // destructor.
 }
 
-}  // namespace mojo
+}  // namespace window_manager