Drop all uses of //base except ObserverList from view mgr client lib

mojo/services/view_manager/public/cpp/tests/view_manager_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 "mojo/services/view_manager/public/cpp/view_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/memory/scoped_vector.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "mojo/services/geometry/public/cpp/geometry_util.h"
 #include "mojo/services/view_manager/public/cpp/lib/view_manager_client_impl.h"
 #include "mojo/services/view_manager/public/cpp/lib/view_private.h"
 #include "mojo/services/view_manager/public/cpp/util.h"
 #include "mojo/services/view_manager/public/cpp/view_manager_client_factory.h"
@@ skipping 64 matching lines @@
                InterfaceRequest<ServiceProvider> services,
                ServiceProviderPtr exposed_services) override {
     callback_.Run(root);
   }
   void OnViewManagerDisconnected(ViewManager* view_manager) override {}
 
   ScopedVector<ApplicationImpl> apps_;
   LoadedCallback callback_;
   scoped_ptr<ViewManagerClientFactory> view_manager_client_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(ConnectApplicationLoader);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(ConnectApplicationLoader);
 };
 
 class BoundsChangeObserver : public ViewObserver {
  public:
   explicit BoundsChangeObserver(View* view) : view_(view) {}
   ~BoundsChangeObserver() override {}
 
  private:
   // Overridden from ViewObserver:
   void OnViewBoundsChanged(View* view,
                            const Rect& old_bounds,
                            const Rect& new_bounds) override {
     DCHECK_EQ(view, view_);
     QuitRunLoop();
   }
 
   View* view_;
 
-  DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver);
 };
 
 // Wait until the bounds of the supplied view change.
 void WaitForBoundsToChange(View* view) {
   BoundsChangeObserver observer(view);
   view->AddObserver(&observer);
   DoRunLoop();
   view->RemoveObserver(&observer);
 }
 
@@ skipping 21 matching lines @@
     size_t count = 1;
     View::Children::const_iterator it = view->children().begin();
     for (; it != view->children().end(); ++it)
       count += CountViews(*it);
     return count;
   }
 
   View* tree_;
   size_t tree_size_;
 
-  DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesObserver);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesObserver);
 };
 
 void WaitForTreeSizeToMatch(View* view, size_t tree_size) {
   TreeSizeMatchesObserver observer(view, tree_size);
   if (observer.IsTreeCorrectSize())
     return;
   view->AddObserver(&observer);
   DoRunLoop();
   view->RemoveObserver(&observer);
 }
@@ skipping 14 matching lines @@
     if (CanQuit())
       QuitRunLoop();
   }
 
   bool CanQuit() {
     return !views_ || views_->empty();
   }
 
   std::set<Id>* views_;
 
-  DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
 };
 
 void WaitForDestruction(ViewManager* view_manager, std::set<Id>* views) {
   DestructionObserver observer(views);
   DCHECK(views);
   if (views) {
     for (std::set<Id>::const_iterator it = views->begin();
           it != views->end(); ++it) {
       view_manager->GetViewById(*it)->AddObserver(&observer);
     }
@@ skipping 12 matching lines @@
   // Overridden from ViewObserver:
   void OnViewReordered(View* view,
                        View* relative_view,
                        OrderDirection direction) override {
     DCHECK_EQ(view, view_);
     QuitRunLoop();
   }
 
   View* view_;
 
-  DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
 };
 
 void WaitForOrderChange(ViewManager* view_manager, View* view) {
   OrderChangeObserver observer(view);
   DoRunLoop();
 }
 
 // Tracks a view's destruction. Query is_valid() for current state.
 class ViewTracker : public ViewObserver {
  public:
@@ skipping 10 matching lines @@
  private:
   // Overridden from ViewObserver:
   void OnViewDestroyed(View* view) override {
     DCHECK_EQ(view, view_);
     view_ = NULL;
   }
 
   int id_;
   View* view_;
 
-  DISALLOW_COPY_AND_ASSIGN(ViewTracker);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(ViewTracker);
 };
 
 }  // namespace
 
 // ViewManager -----------------------------------------------------------------
 
 // These tests model synchronization of two peer connections to the view manager
 // service, that are given access to some root view.
 
 class ViewManagerTest : public testing::Test {
@@ skipping 65 matching lines @@
 
   base::RunLoop* connect_loop_;
   shell::ShellTestHelper test_helper_;
   // Used to receive the most recent view manager loaded by an embed action.
   ViewManager* loaded_view_manager_;
   // The View Manager connection held by the window manager (app running at the
   // root view).
   ViewManager* window_manager_;
   int commit_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(ViewManagerTest);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(ViewManagerTest);
 };
 
 // TODO(sky): all of these tests are disabled as each test triggers running
 // ViewsInit, which tries to register the same set of paths with the
 // PathService, triggering a DCHECK.
 TEST_F(ViewManagerTest, DISABLED_SetUp) {}
 
 TEST_F(ViewManagerTest, DISABLED_Embed) {
   View* view = window_manager()->CreateView();
   view->SetVisible(true);
@@ skipping 185 matching lines @@
 
  private:
   // Overridden from ViewObserver:
   void OnViewVisibilityChanged(View* view) override {
     EXPECT_EQ(view, view_);
     QuitRunLoop();
   }
 
   View* view_;
 
-  DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(ViewManagerTest, DISABLED_Visible) {
   View* view1 = window_manager()->CreateView();
   view1->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view1);
 
   // Embed another app and verify initial state.
@@ skipping 42 matching lines @@
 
  private:
   // Overridden from ViewObserver:
   void OnViewDrawnChanged(View* view) override {
     EXPECT_EQ(view, view_);
     QuitRunLoop();
   }
 
   View* view_;
 
-  DISALLOW_COPY_AND_ASSIGN(DrawnChangeObserver);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(DrawnChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(ViewManagerTest, DISABLED_Drawn) {
   View* view1 = window_manager()->CreateView();
   view1->SetVisible(true);
   window_manager()->GetRoot()->AddChild(view1);
 
   // Embed another app and verify initial state.
@@ skipping 23 matching lines @@
 
 // TODO(beng): tests for focus:
 // - focus between two views known to a connection
 // - focus between views unknown to one of the connections.
 // - focus between views unknown to either connection.
 
 // TODO(sky): need test of root being destroyed with existing views. See
 // 434555 for specific case.
 
 }  // namespace mojo