Mandoline UI Process: Update namespaces and file names

components/mus/public/cpp/lib/view.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 "components/mus/public/cpp/view.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "components/mus/public/cpp/lib/view_private.h"
 #include "components/mus/public/cpp/lib/view_tree_client_impl.h"
 #include "components/mus/public/cpp/view_observer.h"
 #include "components/mus/public/cpp/view_surface.h"
 #include "components/mus/public/cpp/view_tracker.h"
 #include "mojo/application/public/cpp/service_provider_impl.h"
 
-namespace mojo {
+namespace mus {
 
 namespace {
 
 void NotifyViewTreeChangeAtReceiver(
     View* receiver,
     const ViewObserver::TreeChangeParams& params,
     bool change_applied) {
   ViewObserver::TreeChangeParams local_params = params;
   local_params.receiver = receiver;
   if (change_applied) {
@@ skipping 52 matching lines @@
   if (it != children->end()) {
     children->erase(it);
     ViewPrivate(child).ClearParent();
   }
 }
 
 class ScopedOrderChangedNotifier {
  public:
   ScopedOrderChangedNotifier(View* view,
                              View* relative_view,
-                             OrderDirection direction)
+                             mojo::OrderDirection direction)
       : view_(view), relative_view_(relative_view), direction_(direction) {
     FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(view_).observers(),
                       OnViewReordering(view_, relative_view_, direction_));
   }
   ~ScopedOrderChangedNotifier() {
     FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(view_).observers(),
                       OnViewReordered(view_, relative_view_, direction_));
   }
 
  private:
   View* view_;
   View* relative_view_;
-  OrderDirection direction_;
+  mojo::OrderDirection direction_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ScopedOrderChangedNotifier);
 };
 
 // Returns true if the order actually changed.
 bool ReorderImpl(View::Children* children,
                  View* view,
                  View* relative,
-                 OrderDirection direction) {
+                 mojo::OrderDirection direction) {
   DCHECK(relative);
   DCHECK_NE(view, relative);
   DCHECK_EQ(view->parent(), relative->parent());
 
   const size_t child_i =
       std::find(children->begin(), children->end(), view) - children->begin();
   const size_t target_i =
       std::find(children->begin(), children->end(), relative) -
       children->begin();
-  if ((direction == ORDER_DIRECTION_ABOVE && child_i == target_i + 1) ||
-      (direction == ORDER_DIRECTION_BELOW && child_i + 1 == target_i)) {
+  if ((direction == mojo::ORDER_DIRECTION_ABOVE && child_i == target_i + 1) ||
+      (direction == mojo::ORDER_DIRECTION_BELOW && child_i + 1 == target_i)) {
     return false;
   }
 
   ScopedOrderChangedNotifier notifier(view, relative, direction);
 
-  const size_t dest_i = direction == ORDER_DIRECTION_ABOVE
+  const size_t dest_i = direction == mojo::ORDER_DIRECTION_ABOVE
                             ? (child_i < target_i ? target_i : target_i + 1)
                             : (child_i < target_i ? target_i - 1 : target_i);
   children->erase(children->begin() + child_i);
   children->insert(children->begin() + dest_i, view);
 
   return true;
 }
 
 class ScopedSetBoundsNotifier {
  public:
   ScopedSetBoundsNotifier(View* view,
-                          const Rect& old_bounds,
-                          const Rect& new_bounds)
+                          const mojo::Rect& old_bounds,
+                          const mojo::Rect& new_bounds)
       : view_(view), old_bounds_(old_bounds), new_bounds_(new_bounds) {
     FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(view_).observers(),
                       OnViewBoundsChanging(view_, old_bounds_, new_bounds_));
   }
   ~ScopedSetBoundsNotifier() {
     FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(view_).observers(),
                       OnViewBoundsChanged(view_, old_bounds_, new_bounds_));
   }
 
  private:
   View* view_;
-  const Rect old_bounds_;
-  const Rect new_bounds_;
+  const mojo::Rect old_bounds_;
+  const mojo::Rect new_bounds_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ScopedSetBoundsNotifier);
 };
 
 // Some operations are only permitted in the connection that created the view.
 bool OwnsView(ViewTreeConnection* connection, View* view) {
   return !connection ||
          static_cast<ViewTreeClientImpl*>(connection)->OwnsView(view->id());
 }
 
@@ skipping 17 matching lines @@
       children_.erase(children_.begin());
     } else {
       child->Destroy();
       DCHECK(std::find(children_.begin(), children_.end(), child) ==
              children_.end());
     }
   }
   LocalDestroy();
 }
 
-void View::SetBounds(const Rect& bounds) {
+void View::SetBounds(const mojo::Rect& bounds) {
   if (!OwnsView(connection_, this))
     return;
 
   if (bounds_.Equals(bounds))
     return;
 
   if (connection_)
     static_cast<ViewTreeClientImpl*>(connection_)->SetBounds(id_, bounds);
   LocalSetBounds(bounds_, bounds);
 }
 
 void View::SetVisible(bool value) {
   if (visible_ == value)
     return;
 
   if (connection_)
     static_cast<ViewTreeClientImpl*>(connection_)->SetVisible(id_, value);
   LocalSetVisible(value);
 }
 
-scoped_ptr<mojo::ViewSurface> View::RequestSurface() {
+scoped_ptr<ViewSurface> View::RequestSurface() {
   mojo::SurfacePtr surface;
   mojo::SurfaceClientPtr client;
-  mojo::InterfaceRequest<SurfaceClient> client_request = GetProxy(&client);
+  mojo::InterfaceRequest<mojo::SurfaceClient> client_request =
+      GetProxy(&client);
   static_cast<ViewTreeClientImpl*>(connection_)
       ->RequestSurface(id_, GetProxy(&surface), client.Pass());
   return make_scoped_ptr(
-      new mojo::ViewSurface(surface.PassInterface(), client_request.Pass()));
+      new ViewSurface(surface.PassInterface(), client_request.Pass()));
 }
 
 void View::SetSharedProperty(const std::string& name,
                              const std::vector<uint8_t>* value) {
   std::vector<uint8_t> old_value;
   std::vector<uint8_t>* old_value_ptr = nullptr;
   auto it = properties_.find(name);
   if (it != properties_.end()) {
     old_value = it->second;
     old_value_ptr = &old_value;
 
     if (value && old_value == *value)
       return;
   } else if (!value) {
     // This property isn't set in |properties_| and |value| is NULL, so there's
     // no change.
     return;
   }
 
   if (value) {
     properties_[name] = *value;
   } else if (it != properties_.end()) {
     properties_.erase(it);
   }
 
   // TODO: add test coverage of this (450303).
   if (connection_) {
-    Array<uint8_t> transport_value;
+    mojo::Array<uint8_t> transport_value;
     if (value) {
       transport_value.resize(value->size());
       if (value->size())
         memcpy(&transport_value.front(), &(value->front()), value->size());
     }
     static_cast<ViewTreeClientImpl*>(connection_)
         ->SetProperty(id_, name, transport_value.Pass());
   }
 
   FOR_EACH_OBSERVER(
@@ skipping 47 matching lines @@
   LocalRemoveChild(child);
   if (connection_) {
     static_cast<ViewTreeClientImpl*>(connection_)
         ->RemoveChild(child->id(), id_);
   }
 }
 
 void View::MoveToFront() {
   if (!parent_ || parent_->children_.back() == this)
     return;
-  Reorder(parent_->children_.back(), ORDER_DIRECTION_ABOVE);
+  Reorder(parent_->children_.back(), mojo::ORDER_DIRECTION_ABOVE);
 }
 
 void View::MoveToBack() {
   if (!parent_ || parent_->children_.front() == this)
     return;
-  Reorder(parent_->children_.front(), ORDER_DIRECTION_BELOW);
+  Reorder(parent_->children_.front(), mojo::ORDER_DIRECTION_BELOW);
 }
 
-void View::Reorder(View* relative, OrderDirection direction) {
+void View::Reorder(View* relative, mojo::OrderDirection direction) {
   if (!LocalReorder(relative, direction))
     return;
   if (connection_) {
     static_cast<ViewTreeClientImpl*>(connection_)
         ->Reorder(id_, relative->id(), direction);
   }
 }
 
 bool View::Contains(View* child) const {
   if (!child)
@@ skipping 15 matching lines @@
   // TODO(beng): this could be improved depending on how we decide to own views.
   Children::const_iterator it = children_.begin();
   for (; it != children_.end(); ++it) {
     View* view = (*it)->GetChildById(id);
     if (view)
       return view;
   }
   return NULL;
 }
 
-void View::SetTextInputState(TextInputStatePtr state) {
+void View::SetTextInputState(mojo::TextInputStatePtr state) {
   if (connection_) {
     static_cast<ViewTreeClientImpl*>(connection_)
         ->SetViewTextInputState(id_, state.Pass());
   }
 }
 
-void View::SetImeVisibility(bool visible, TextInputStatePtr state) {
+void View::SetImeVisibility(bool visible, mojo::TextInputStatePtr state) {
   // SetImeVisibility() shouldn't be used if the view is not editable.
-  DCHECK(state.is_null() || state->type != TEXT_INPUT_TYPE_NONE);
+  DCHECK(state.is_null() || state->type != mojo::TEXT_INPUT_TYPE_NONE);
   if (connection_) {
     static_cast<ViewTreeClientImpl*>(connection_)
         ->SetImeVisibility(id_, visible, state.Pass());
   }
 }
 
 void View::SetFocus() {
   if (connection_)
     static_cast<ViewTreeClientImpl*>(connection_)->SetFocus(id_);
 }
 
 bool View::HasFocus() const {
   return connection_ && connection_->GetFocusedView() == this;
 }
 
-void View::Embed(ViewTreeClientPtr client) {
+void View::Embed(mojo::ViewTreeClientPtr client) {
   Embed(client.Pass(), base::Bind(&EmptyEmbedCallback));
 }
 
-void View::Embed(ViewTreeClientPtr client, const EmbedCallback& callback) {
+void View::Embed(mojo::ViewTreeClientPtr client,
+                 const EmbedCallback& callback) {
   if (PrepareForEmbed()) {
     static_cast<ViewTreeClientImpl*>(connection_)
         ->Embed(id_, client.Pass(), callback);
   } else {
     callback.Run(false, 0);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // View, protected:
 
 namespace {
 
-ViewportMetricsPtr CreateEmptyViewportMetrics() {
-  ViewportMetricsPtr metrics = ViewportMetrics::New();
-  metrics->size_in_pixels = Size::New();
+mojo::ViewportMetricsPtr CreateEmptyViewportMetrics() {
+  mojo::ViewportMetricsPtr metrics = mojo::ViewportMetrics::New();
+  metrics->size_in_pixels = mojo::Size::New();
   // TODO(vtl): The |.Pass()| below is only needed due to an MSVS bug; remove it
   // once that's fixed.
   return metrics.Pass();
 }
 
 }  // namespace
 
 View::View()
     : connection_(NULL),
       id_(static_cast<Id>(-1)),
@@ skipping 83 matching lines @@
   children_.push_back(child);
   child->parent_ = this;
 }
 
 void View::LocalRemoveChild(View* child) {
   DCHECK_EQ(this, child->parent());
   ScopedTreeNotifier notifier(child, this, NULL);
   RemoveChildImpl(child, &children_);
 }
 
-bool View::LocalReorder(View* relative, OrderDirection direction) {
+bool View::LocalReorder(View* relative, mojo::OrderDirection direction) {
   return ReorderImpl(&parent_->children_, this, relative, direction);
 }
 
-void View::LocalSetBounds(const Rect& old_bounds, const Rect& new_bounds) {
+void View::LocalSetBounds(const mojo::Rect& old_bounds,
+                          const mojo::Rect& new_bounds) {
   DCHECK(old_bounds.x == bounds_.x);
   DCHECK(old_bounds.y == bounds_.y);
   DCHECK(old_bounds.width == bounds_.width);
   DCHECK(old_bounds.height == bounds_.height);
   ScopedSetBoundsNotifier notifier(this, old_bounds, new_bounds);
   bounds_ = new_bounds;
 }
 
-void View::LocalSetViewportMetrics(const ViewportMetrics& old_metrics,
-                                   const ViewportMetrics& new_metrics) {
+void View::LocalSetViewportMetrics(const mojo::ViewportMetrics& old_metrics,
+                                   const mojo::ViewportMetrics& new_metrics) {
   // TODO(eseidel): We could check old_metrics against viewport_metrics_.
   viewport_metrics_ = new_metrics.Clone();
   FOR_EACH_OBSERVER(
       ViewObserver, observers_,
       OnViewViewportMetricsChanged(this, old_metrics, new_metrics));
 }
 
 void View::LocalSetDrawn(bool value) {
   if (drawn_ == value)
     return;
@@ skipping 70 matching lines @@
   if (!OwnsView(connection_, this) &&
       !static_cast<ViewTreeClientImpl*>(connection_)->is_embed_root()) {
     return false;
   }
 
   while (!children_.empty())
     RemoveChild(children_[0]);
   return true;
 }
 
-}  // namespace mojo
+}  // namespace mus