Revert of Mandoline UI Process: Update namespaces and file names

components/mus/public/cpp/tests/view_unittest.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 "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "components/mus/public/cpp/lib/view_private.h"
 #include "components/mus/public/cpp/util.h"
 #include "components/mus/public/cpp/view_observer.h"
 #include "components/mus/public/cpp/view_property.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace mus {
+namespace mojo {
 
 // View ------------------------------------------------------------------------
 
 typedef testing::Test ViewTest;
 
 // Subclass with public ctor/dtor.
 class TestView : public View {
  public:
   TestView() { ViewPrivate(this).set_id(1); }
   ~TestView() {}
@@ skipping 390 matching lines @@
   EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back()));
 }
 
 namespace {
 
 class OrderChangeObserver : public ViewObserver {
  public:
   struct Change {
     View* view;
     View* relative_view;
-    mojo::OrderDirection direction;
+    OrderDirection direction;
   };
   typedef std::vector<Change> Changes;
 
   explicit OrderChangeObserver(View* observee) : observee_(observee) {
     observee_->AddObserver(this);
   }
   ~OrderChangeObserver() override { observee_->RemoveObserver(this); }
 
   Changes GetAndClearChanges() {
     Changes changes;
     changes_.swap(changes);
     return changes;
   }
 
  private:
   // Overridden from ViewObserver:
   void OnViewReordering(View* view,
                         View* relative_view,
-                        mojo::OrderDirection direction) override {
+                        OrderDirection direction) override {
     OnViewReordered(view, relative_view, direction);
   }
 
   void OnViewReordered(View* view,
                        View* relative_view,
-                       mojo::OrderDirection direction) override {
+                       OrderDirection direction) override {
     Change change;
     change.view = view;
     change.relative_view = relative_view;
     change.direction = direction;
     changes_.push_back(change);
   }
 
   View* observee_;
   Changes changes_;
 
@@ skipping 19 matching lines @@
     // Move v11 to front.
     // Resulting order: v12, v13, v11
     v11.MoveToFront();
     EXPECT_EQ(&v12, v1.children().front());
     EXPECT_EQ(&v11, v1.children().back());
 
     OrderChangeObserver::Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(&v11, changes[0].view);
     EXPECT_EQ(&v13, changes[0].relative_view);
-    EXPECT_EQ(mojo::ORDER_DIRECTION_ABOVE, changes[0].direction);
+    EXPECT_EQ(ORDER_DIRECTION_ABOVE, changes[0].direction);
 
     EXPECT_EQ(&v11, changes[1].view);
     EXPECT_EQ(&v13, changes[1].relative_view);
-    EXPECT_EQ(mojo::ORDER_DIRECTION_ABOVE, changes[1].direction);
+    EXPECT_EQ(ORDER_DIRECTION_ABOVE, changes[1].direction);
   }
 
   {
     OrderChangeObserver observer(&v11);
 
     // Move v11 to back.
     // Resulting order: v11, v12, v13
     v11.MoveToBack();
     EXPECT_EQ(&v11, v1.children().front());
     EXPECT_EQ(&v13, v1.children().back());
 
     OrderChangeObserver::Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(&v11, changes[0].view);
     EXPECT_EQ(&v12, changes[0].relative_view);
-    EXPECT_EQ(mojo::ORDER_DIRECTION_BELOW, changes[0].direction);
+    EXPECT_EQ(ORDER_DIRECTION_BELOW, changes[0].direction);
 
     EXPECT_EQ(&v11, changes[1].view);
     EXPECT_EQ(&v12, changes[1].relative_view);
-    EXPECT_EQ(mojo::ORDER_DIRECTION_BELOW, changes[1].direction);
+    EXPECT_EQ(ORDER_DIRECTION_BELOW, changes[1].direction);
   }
 
   {
     OrderChangeObserver observer(&v11);
 
     // Move v11 above v12.
     // Resulting order: v12. v11, v13
-    v11.Reorder(&v12, mojo::ORDER_DIRECTION_ABOVE);
+    v11.Reorder(&v12, ORDER_DIRECTION_ABOVE);
     EXPECT_EQ(&v12, v1.children().front());
     EXPECT_EQ(&v13, v1.children().back());
 
     OrderChangeObserver::Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(&v11, changes[0].view);
     EXPECT_EQ(&v12, changes[0].relative_view);
-    EXPECT_EQ(mojo::ORDER_DIRECTION_ABOVE, changes[0].direction);
+    EXPECT_EQ(ORDER_DIRECTION_ABOVE, changes[0].direction);
 
     EXPECT_EQ(&v11, changes[1].view);
     EXPECT_EQ(&v12, changes[1].relative_view);
-    EXPECT_EQ(mojo::ORDER_DIRECTION_ABOVE, changes[1].direction);
+    EXPECT_EQ(ORDER_DIRECTION_ABOVE, changes[1].direction);
   }
 
   {
     OrderChangeObserver observer(&v11);
 
     // Move v11 below v12.
     // Resulting order: v11, v12, v13
-    v11.Reorder(&v12, mojo::ORDER_DIRECTION_BELOW);
+    v11.Reorder(&v12, ORDER_DIRECTION_BELOW);
     EXPECT_EQ(&v11, v1.children().front());
     EXPECT_EQ(&v13, v1.children().back());
 
     OrderChangeObserver::Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(&v11, changes[0].view);
     EXPECT_EQ(&v12, changes[0].relative_view);
-    EXPECT_EQ(mojo::ORDER_DIRECTION_BELOW, changes[0].direction);
+    EXPECT_EQ(ORDER_DIRECTION_BELOW, changes[0].direction);
 
     EXPECT_EQ(&v11, changes[1].view);
     EXPECT_EQ(&v12, changes[1].relative_view);
-    EXPECT_EQ(mojo::ORDER_DIRECTION_BELOW, changes[1].direction);
+    EXPECT_EQ(ORDER_DIRECTION_BELOW, changes[1].direction);
   }
 }
 
 namespace {
 
 typedef std::vector<std::string> Changes;
 
 std::string ViewIdToString(Id id) {
   return (id == 0) ? "null"
                    : base::StringPrintf("%d,%d", HiWord(id), LoWord(id));
 }
 
-std::string RectToString(const mojo::Rect& rect) {
+std::string RectToString(const Rect& rect) {
   return base::StringPrintf("%d,%d %dx%d", rect.x, rect.y, rect.width,
                             rect.height);
 }
 
 class BoundsChangeObserver : public ViewObserver {
  public:
   explicit BoundsChangeObserver(View* view) : view_(view) {
     view_->AddObserver(this);
   }
   ~BoundsChangeObserver() override { view_->RemoveObserver(this); }
 
   Changes GetAndClearChanges() {
     Changes changes;
     changes.swap(changes_);
     return changes;
   }
 
  private:
   // Overridden from ViewObserver:
   void OnViewBoundsChanging(View* view,
-                            const mojo::Rect& old_bounds,
-                            const mojo::Rect& new_bounds) override {
+                            const Rect& old_bounds,
+                            const Rect& new_bounds) override {
     changes_.push_back(base::StringPrintf(
         "view=%s old_bounds=%s new_bounds=%s phase=changing",
         ViewIdToString(view->id()).c_str(), RectToString(old_bounds).c_str(),
         RectToString(new_bounds).c_str()));
   }
   void OnViewBoundsChanged(View* view,
-                           const mojo::Rect& old_bounds,
-                           const mojo::Rect& new_bounds) override {
+                           const Rect& old_bounds,
+                           const Rect& new_bounds) override {
     changes_.push_back(base::StringPrintf(
         "view=%s old_bounds=%s new_bounds=%s phase=changed",
         ViewIdToString(view->id()).c_str(), RectToString(old_bounds).c_str(),
         RectToString(new_bounds).c_str()));
   }
 
   View* view_;
   Changes changes_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(ViewObserverTest, SetBounds) {
   TestView v1;
   {
     BoundsChangeObserver observer(&v1);
-    mojo::Rect rect;
+    Rect rect;
     rect.width = rect.height = 100;
     v1.SetBounds(rect);
 
     Changes changes = observer.GetAndClearChanges();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(
         "view=0,1 old_bounds=0,0 0x0 new_bounds=0,0 100x100 phase=changing",
         changes[0]);
     EXPECT_EQ(
         "view=0,1 old_bounds=0,0 0x0 new_bounds=0,0 100x100 phase=changed",
@@ skipping 236 matching lines @@
   v1.SetLocalProperty(&prop, 3);
   EXPECT_EQ(PropertyChangeInfo(&prop, -2), o.PropertyChangeInfoAndClear());
   v1.ClearLocalProperty(&prop);
   EXPECT_EQ(PropertyChangeInfo(&prop, 3), o.PropertyChangeInfoAndClear());
 
   // Sanity check to see if |PropertyChangeInfoAndClear| really clears.
   EXPECT_EQ(PropertyChangeInfo(reinterpret_cast<const void*>(NULL), -3),
             o.PropertyChangeInfoAndClear());
 }
 
-}  // namespace mus
+}  // namespace mojo