Nukes view_manager namespace

mojo/examples/png_viewer/png_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 <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_tokenizer.h"
 #include "mojo/examples/media_viewer/media_viewer.mojom.h"
 #include "mojo/public/cpp/application/application_connection.h"
@@ skipping 71 matching lines @@
     }
 
     SkBitmap bitmap;
     gfx::PNGCodec::Decode(static_cast<const unsigned char*>(data),
                           content_length, &bitmap);
     UpdateView(node_id, bitmap);
 
     delete[] data;
   }
 
-  void UpdateView(view_manager::Id node_id, const SkBitmap& bitmap);
+  void UpdateView(Id node_id, const SkBitmap& bitmap);
 
   int GetContentLength(const Array<String>& headers) {
     for (size_t i = 0; i < headers.size(); ++i) {
       base::StringTokenizer t(headers[i], ": ;=");
       while (t.GetNext()) {
         if (!t.token_is_delim() && t.token() == "Content-Length") {
           while (t.GetNext()) {
             if (!t.token_is_delim())
               return atoi(t.token().c_str());
           }
         }
       }
     }
     return 0;
   }
 
   PNGViewer* viewer_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigatorImpl);
 };
 
 class PNGViewer
     : public ApplicationDelegate,
-      public view_manager::ViewManagerDelegate,
-      public view_manager::NodeObserver,
+      public ViewManagerDelegate,
+      public NodeObserver,
       public InterfaceFactoryWithContext<NavigatorImpl, PNGViewer>,
       public InterfaceFactoryWithContext<ZoomableMediaImpl, PNGViewer> {
  public:
   PNGViewer()
       : InterfaceFactoryWithContext<NavigatorImpl, PNGViewer>(this),
         InterfaceFactoryWithContext<ZoomableMediaImpl, PNGViewer>(this),
         content_view_(NULL),
         root_(NULL),
         zoom_percentage_(kDefaultZoomPercentage),
         view_manager_client_factory_(this) {}
   virtual ~PNGViewer() {
     if (root_)
       root_->RemoveObserver(this);
   }
 
-  void UpdateView(view_manager::Id node_id, const SkBitmap& bitmap) {
+  void UpdateView(Id node_id, const SkBitmap& bitmap) {
     bitmap_ = bitmap;
     zoom_percentage_ = kDefaultZoomPercentage;
     DrawBitmap();
   }
 
   void ZoomIn() {
     if (zoom_percentage_ >= kMaxZoomPercentage)
       return;
     zoom_percentage_ += kZoomStep;
     DrawBitmap();
@@ skipping 21 matching lines @@
 
   // Overridden from ApplicationDelegate:
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
       MOJO_OVERRIDE {
     connection->AddService<navigation::Navigator>(this);
     connection->AddService<ZoomableMedia>(this);
     connection->AddService(&view_manager_client_factory_);
     return true;
   }
 
-  // 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_ = root;
     root_->AddObserver(this);
-    content_view_ = view_manager::View::Create(view_manager);
+    content_view_ = View::Create(view_manager);
     root_->SetActiveView(content_view_);
     content_view_->SetColor(SK_ColorGRAY);
     if (!bitmap_.isNull())
       DrawBitmap();
   }
   virtual void OnViewManagerDisconnected(
-      view_manager::ViewManager* view_manager) OVERRIDE {
+      ViewManager* view_manager) OVERRIDE {
     base::MessageLoop::current()->Quit();
   }
 
   void DrawBitmap() {
     if (!content_view_)
       return;
 
     skia::RefPtr<SkCanvas> canvas(skia::AdoptRef(skia::CreatePlatformCanvas(
         content_view_->node()->bounds().width(),
         content_view_->node()->bounds().height(),
         true)));
     canvas->drawColor(SK_ColorGRAY);
     SkPaint paint;
     SkScalar scale =
         SkFloatToScalar(zoom_percentage_ * 1.0f / kDefaultZoomPercentage);
     canvas->scale(scale, scale);
     canvas->drawBitmap(bitmap_, 0, 0, &paint);
     content_view_->SetContents(skia::GetTopDevice(*canvas)->accessBitmap(true));
   }
 
   // NodeObserver:
-  virtual void OnNodeBoundsChanged(view_manager::Node* node,
+  virtual void OnNodeBoundsChanged(Node* node,
                                    const gfx::Rect& old_bounds,
                                    const gfx::Rect& new_bounds) OVERRIDE {
     DCHECK_EQ(node, root_);
     DrawBitmap();
   }
-  virtual void OnNodeDestroyed(view_manager::Node* node) OVERRIDE {
+  virtual void OnNodeDestroyed(Node* node) OVERRIDE {
     DCHECK_EQ(node, root_);
     node->RemoveObserver(this);
     root_ = NULL;
   }
 
-  view_manager::View* content_view_;
-  view_manager::Node* root_;
+  View* content_view_;
+  Node* root_;
   SkBitmap bitmap_;
   uint16_t zoom_percentage_;
-  view_manager::ViewManagerClientFactory view_manager_client_factory_;
+  ViewManagerClientFactory view_manager_client_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PNGViewer);
 };
 
 void ZoomableMediaImpl::ZoomIn() {
   viewer_->ZoomIn();
 }
 
 void ZoomableMediaImpl::ZoomOut() {
   viewer_->ZoomOut();
 }
 
 void ZoomableMediaImpl::ZoomToActualSize() {
   viewer_->ZoomToActualSize();
 }
 
-void NavigatorImpl::UpdateView(view_manager::Id node_id,
+void NavigatorImpl::UpdateView(Id node_id,
                                const SkBitmap& bitmap) {
   viewer_->UpdateView(node_id, bitmap);
 }
 
 }  // namespace examples
 
 // static
 ApplicationDelegate* ApplicationDelegate::Create() {
   return new examples::PNGViewer;
 }
 
 }  // namespace mojo