Mandoline: Rename components/view_manager to components/mus

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/view_manager/public/cpp/view.h"
+#include "components/mus/public/cpp/view.h"
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
-#include "components/view_manager/public/cpp/lib/view_private.h"
-#include "components/view_manager/public/cpp/util.h"
-#include "components/view_manager/public/cpp/view_observer.h"
-#include "components/view_manager/public/cpp/view_property.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 mojo {
 
 // View ------------------------------------------------------------------------
 
 typedef testing::Test ViewTest;
 
 // Subclass with public ctor/dtor.
 class TestView : public View {
  public:
-  TestView() {
-    ViewPrivate(this).set_id(1);
-  }
+  TestView() { ViewPrivate(this).set_id(1); }
   ~TestView() {}
 
  private:
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestView);
 };
 
 TEST_F(ViewTest, AddChild) {
   TestView v1;
   TestView v11;
   v1.AddChild(&v11);
@@ skipping 147 matching lines @@
 
   EXPECT_EQ(p3, TestProperty::last_deleted());
 }
 
 // ViewObserver --------------------------------------------------------
 
 typedef testing::Test ViewObserverTest;
 
 bool TreeChangeParamsMatch(const ViewObserver::TreeChangeParams& lhs,
                            const ViewObserver::TreeChangeParams& rhs) {
-  return lhs.target == rhs.target &&  lhs.old_parent == rhs.old_parent &&
-      lhs.new_parent == rhs.new_parent && lhs.receiver == rhs.receiver;
+  return lhs.target == rhs.target && lhs.old_parent == rhs.old_parent &&
+         lhs.new_parent == rhs.new_parent && lhs.receiver == rhs.receiver;
 }
 
 class TreeChangeObserver : public ViewObserver {
  public:
   explicit TreeChangeObserver(View* observee) : observee_(observee) {
     observee_->AddObserver(this);
   }
   ~TreeChangeObserver() override { observee_->RemoveObserver(this); }
 
-  void Reset() {
-    received_params_.clear();
-  }
+  void Reset() { received_params_.clear(); }
 
   const std::vector<TreeChangeParams>& received_params() {
     return received_params_;
   }
 
  private:
   // Overridden from ViewObserver:
   void OnTreeChanging(const TreeChangeParams& params) override {
-     received_params_.push_back(params);
-   }
-   void OnTreeChanged(const TreeChangeParams& params) override {
+    received_params_.push_back(params);
+  }
+  void OnTreeChanged(const TreeChangeParams& params) override {
     received_params_.push_back(params);
   }
 
   View* observee_;
   std::vector<TreeChangeParams> received_params_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TreeChangeObserver);
 };
 
 // Adds/Removes v11 to v1.
@@ skipping 329 matching lines @@
     EXPECT_EQ(&v12, changes[1].relative_view);
     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));
+  return (id == 0) ? "null"
+                   : base::StringPrintf("%d,%d", HiWord(id), LoWord(id));
 }
 
 std::string RectToString(const Rect& rect) {
-  return base::StringPrintf("%d,%d %dx%d",
-                            rect.x, rect.y, rect.width, rect.height);
+  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 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()));
+    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 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()));
+    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
 
@@ skipping 202 matching lines @@
   }
 }
 
 namespace {
 
 typedef std::pair<const void*, intptr_t> PropertyChangeInfo;
 
 class LocalPropertyChangeObserver : public ViewObserver {
  public:
   explicit LocalPropertyChangeObserver(View* view)
-      : view_(view),
-        property_key_(nullptr),
-        old_property_value_(-1) {
+      : view_(view), property_key_(nullptr), old_property_value_(-1) {
     view_->AddObserver(this);
   }
   ~LocalPropertyChangeObserver() override { view_->RemoveObserver(this); }
 
   PropertyChangeInfo PropertyChangeInfoAndClear() {
     PropertyChangeInfo result(property_key_, old_property_value_);
     property_key_ = NULL;
     old_property_value_ = -3;
     return result;
   }
@@ skipping 24 matching lines @@
   v1.SetLocalProperty(&prop, 1);
   EXPECT_EQ(PropertyChangeInfo(&prop, -2), o.PropertyChangeInfoAndClear());
   v1.SetLocalProperty(&prop, -2);
   EXPECT_EQ(PropertyChangeInfo(&prop, 1), o.PropertyChangeInfoAndClear());
   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());
+  EXPECT_EQ(PropertyChangeInfo(reinterpret_cast<const void*>(NULL), -3),
+            o.PropertyChangeInfoAndClear());
 }
 
 }  // namespace mojo