Nukes view_manager namespace

mojo/examples/media_viewer/media_viewer.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 <map>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 119 matching lines @@
    public:
     virtual ~Delegate() {}
 
     virtual void ButtonPressed(ControlType type) = 0;
   };
 
   ControlPanel(Delegate* delegate) : delegate_(delegate), buttons_() {}
 
   virtual ~ControlPanel() {}
 
-  void Initialize(view_manager::Node* node) {
+  void Initialize(Node* node) {
     const char* kNames[] = { "Zoom In", "Actual Size", "Zoom Out" };
 
     views::WidgetDelegateView* widget_delegate = new views::WidgetDelegateView;
 
     widget_delegate->GetContentsView()->SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kHorizontal, 5, 2, 5));
 
     widget_delegate->GetContentsView()->set_background(
         views::Background::CreateSolidBackground(SK_ColorLTGRAY));
 
@@ skipping 46 matching lines @@
       navigation::NavigationDetailsPtr navigation_details,
       navigation::ResponseDetailsPtr response_details) OVERRIDE;
 
   MediaViewer* viewer_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigatorImpl);
 };
 
 class MediaViewer
     : public ApplicationDelegate,
-      public view_manager::ViewManagerDelegate,
+      public ViewManagerDelegate,
       public ControlPanel::Delegate,
-      public view_manager::NodeObserver,
+      public NodeObserver,
       public InterfaceFactoryWithContext<NavigatorImpl, MediaViewer> {
  public:
   MediaViewer()
       : InterfaceFactoryWithContext(this),
         app_(NULL),
         view_manager_(NULL),
         view_manager_client_factory_(this),
         root_node_(NULL),
         control_node_(NULL),
         content_node_(NULL),
@@ skipping 56 matching lines @@
   }
 
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
       OVERRIDE {
     connection->AddService(this);
     connection->AddService(&view_manager_client_factory_);
     return true;
   }
 
   void LayoutNodes() {
-    view_manager::Node* root = content_node_->parent();
+    Node* root = content_node_->parent();
     gfx::Rect control_bounds(root->bounds().width(), 28);
     control_node_->SetBounds(control_bounds);
     gfx::Rect content_bounds(0, control_bounds.height(), root->bounds().width(),
                              root->bounds().height() - control_bounds.height());
     content_node_->SetBounds(content_bounds);
   }
 
-  // Overridden from view_manager::ViewManagerDelegate:
-  virtual void OnRootAdded(view_manager::ViewManager* view_manager,
-                           view_manager::Node* root) OVERRIDE {
+  // Overridden from ViewManagerDelegate:
+  virtual void OnRootAdded(ViewManager* view_manager, Node* root) OVERRIDE {
     root_node_ = root;
     view_manager_ = view_manager;
 
-    control_node_ = view_manager::Node::Create(view_manager_);
+    control_node_ = Node::Create(view_manager_);
     root_node_->AddChild(control_node_);
 
-    content_node_ = view_manager::Node::Create(view_manager_);
+    content_node_ = Node::Create(view_manager_);
     root_node_->AddChild(content_node_);
 
-    control_node_->SetActiveView(view_manager::View::Create(view_manager_));
+    control_node_->SetActiveView(View::Create(view_manager_));
     control_panel_.Initialize(control_node_);
 
     LayoutNodes();
     root_node_->AddObserver(this);
 
     if (pending_navigate_request_) {
       scoped_ptr<PendingNavigateRequest> request(
           pending_navigate_request_.release());
 
       Navigate(request->node_id, request->navigation_details.Pass(),
                request->response_details.Pass());
     }
   }
   virtual void OnViewManagerDisconnected(
-      view_manager::ViewManager* view_manager) OVERRIDE {
+      ViewManager* view_manager) OVERRIDE {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // Overridden from ControlPanel::Delegate:
   virtual void ButtonPressed(ControlPanel::ControlType type) OVERRIDE {
     switch (type) {
       case ControlPanel::CONTROL_ZOOM_IN:
         zoomable_media_->ZoomIn();
         break;
       case ControlPanel::CONTROL_ACTUAL_SIZE:
        zoomable_media_->ZoomToActualSize();
         break;
       case ControlPanel::CONTROL_ZOOM_OUT:
         zoomable_media_->ZoomOut();
         break;
       default:
         NOTIMPLEMENTED();
     }
   }
 
   // NodeObserver:
-  virtual void OnNodeBoundsChanged(view_manager::Node* node,
+  virtual void OnNodeBoundsChanged(Node* node,
                                    const gfx::Rect& old_bounds,
                                    const gfx::Rect& new_bounds) OVERRIDE {
     LayoutNodes();
   }
-  virtual void OnNodeDestroyed(view_manager::Node* node) OVERRIDE {
+  virtual void OnNodeDestroyed(Node* node) OVERRIDE {
     DCHECK_EQ(node, root_node_);
     node->RemoveObserver(this);
     root_node_ = NULL;
   }
 
   std::string GetHandlerForContentType(const std::string& content_type) {
     HandlerMap::const_iterator it = handler_map_.find(content_type);
     return it != handler_map_.end() ? it->second : std::string();
   }
 
   ApplicationImpl* app_;
   scoped_ptr<ViewsInit> views_init_;
-  view_manager::ViewManager* view_manager_;
-  view_manager::ViewManagerClientFactory view_manager_client_factory_;
-  view_manager::Node* root_node_;
-  view_manager::Node* control_node_;
-  view_manager::Node* content_node_;
+  ViewManager* view_manager_;
+  ViewManagerClientFactory view_manager_client_factory_;
+  Node* root_node_;
+  Node* control_node_;
+  Node* content_node_;
   ControlPanel control_panel_;
   ZoomableMediaPtr zoomable_media_;
   HandlerMap handler_map_;
   scoped_ptr<PendingNavigateRequest> pending_navigate_request_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaViewer);
 };
 
 void NavigatorImpl::Navigate(
     uint32_t node_id,
     navigation::NavigationDetailsPtr navigation_details,
     navigation::ResponseDetailsPtr response_details) {
   viewer_->Navigate(node_id, navigation_details.Pass(),
                     response_details.Pass());
 }
 
 }  // namespace examples
 
 // static
 ApplicationDelegate* ApplicationDelegate::Create() {
   return new examples::MediaViewer;
 }
 
 }  // namespace mojo