Revert of Mandoline UI Process: Update namespaces and file names

components/mus/view_tree_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 <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "components/mus/client_connection.h"
 #include "components/mus/connection_manager.h"
@@ skipping 15 matching lines @@
 #include "ui/gfx/geometry/rect.h"
 
 using mojo::Array;
 using mojo::ERROR_CODE_NONE;
 using mojo::InterfaceRequest;
 using mojo::ServiceProvider;
 using mojo::ServiceProviderPtr;
 using mojo::String;
 using mojo::ViewDataPtr;
 
-namespace mus {
+namespace view_manager {
 namespace {
 
 // -----------------------------------------------------------------------------
 
 // ViewTreeClient implementation that logs all calls to a TestChangeTracker.
 // TODO(sky): refactor so both this and ViewTreeAppTest share code.
 class TestViewTreeClient : public mojo::ViewTreeClient {
  public:
   TestViewTreeClient() {}
   ~TestViewTreeClient() override {}
 
   TestChangeTracker* tracker() { return &tracker_; }
 
  private:
   // ViewTreeClient:
   void OnEmbed(uint16_t connection_id,
                ViewDataPtr root,
                mojo::ViewTreePtr tree,
-               Id focused_view_id,
+               mojo::Id focused_view_id,
                uint32_t access_policy) override {
     // TODO(sky): add test coverage of |focused_view_id|.
     tracker_.OnEmbed(connection_id, root.Pass());
   }
   void OnEmbeddedAppDisconnected(uint32_t view) override {
     tracker_.OnEmbeddedAppDisconnected(view);
   }
   void OnUnembed() override { tracker_.OnUnembed(); }
   void OnViewBoundsChanged(uint32_t view,
                            mojo::RectPtr old_bounds,
@@ skipping 75 matching lines @@
 
   TestClientConnection* last_connection() { return last_connection_; }
 
  private:
   // ConnectionManagerDelegate:
   void OnNoMoreRootConnections() override {}
 
   ClientConnection* CreateClientConnectionForEmbedAtView(
       ConnectionManager* connection_manager,
       mojo::InterfaceRequest<mojo::ViewTree> service_request,
-      ConnectionSpecificId creator_id,
+      mojo::ConnectionSpecificId creator_id,
       mojo::URLRequestPtr request,
       const ViewId& root_id,
       uint32_t policy_bitmask) override {
     scoped_ptr<ViewTreeImpl> service(new ViewTreeImpl(
         connection_manager, creator_id, root_id, policy_bitmask));
     last_connection_ = new TestClientConnection(service.Pass());
     return last_connection_;
   }
   ClientConnection* CreateClientConnectionForEmbedAtView(
       ConnectionManager* connection_manager,
       mojo::InterfaceRequest<mojo::ViewTree> service_request,
-      ConnectionSpecificId creator_id,
+      mojo::ConnectionSpecificId creator_id,
       const ViewId& root_id,
       uint32_t policy_bitmask,
       mojo::ViewTreeClientPtr client) override {
     // Used by ConnectionManager::AddRoot.
     scoped_ptr<ViewTreeImpl> service(new ViewTreeImpl(
         connection_manager, creator_id, root_id, policy_bitmask));
     last_connection_ = new TestClientConnection(service.Pass());
     return last_connection_;
   }
 
@@ skipping 56 matching lines @@
 };
 
 // Factory that dispenses TestDisplayManagers.
 class TestDisplayManagerFactory : public DisplayManagerFactory {
  public:
   TestDisplayManagerFactory() {}
   ~TestDisplayManagerFactory() {}
   DisplayManager* CreateDisplayManager(
       bool is_headless,
       mojo::ApplicationImpl* app_impl,
-      const scoped_refptr<GpuState>& gpu_state,
-      const scoped_refptr<SurfacesState>& surfaces_state) override {
+      const scoped_refptr<gles2::GpuState>& gpu_state,
+      const scoped_refptr<surfaces::SurfacesState>& surfaces_state) override {
     return new TestDisplayManager();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestDisplayManagerFactory);
 };
 
 mojo::EventPtr CreatePointerDownEvent(int x, int y) {
   mojo::EventPtr event(mojo::Event::New());
   event->action = mojo::EVENT_TYPE_POINTER_DOWN;
@@ skipping 43 matching lines @@
   TestViewTreeHostConnection* host_connection() { return host_connection_; }
   DisplayManagerDelegate* display_manager_delegate() {
     return host_connection()->view_tree_host();
   }
 
  protected:
   // testing::Test:
   void SetUp() override {
     DisplayManager::set_factory_for_testing(&display_manager_factory_);
     // TODO(fsamuel): This is probably broken. We need a root.
-    connection_manager_.reset(
-        new ConnectionManager(&delegate_, scoped_refptr<SurfacesState>()));
+    connection_manager_.reset(new ConnectionManager(
+        &delegate_, scoped_refptr<surfaces::SurfacesState>()));
     ViewTreeHostImpl* host = new ViewTreeHostImpl(
         mojo::ViewTreeHostClientPtr(), connection_manager_.get(),
-        true /* is_headless */, nullptr, scoped_refptr<GpuState>(),
-        scoped_refptr<SurfacesState>());
+        true /* is_headless */, nullptr, scoped_refptr<gles2::GpuState>(),
+        scoped_refptr<surfaces::SurfacesState>());
     // TODO(fsamuel): This is way too magical. We need to find a better way to
     // manage lifetime.
     host_connection_ = new TestViewTreeHostConnection(
         make_scoped_ptr(host), connection_manager_.get());
     host->Init(host_connection_);
     wm_client_ = delegate_.last_client();
   }
 
  private:
   // TestViewTreeClient that is used for the WM connection.
@@ skipping 119 matching lines @@
   ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
   EXPECT_EQ("Focused id=2,1",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   ASSERT_EQ(2u, embed_connection->tracker()->changes()->size());
   EXPECT_EQ("Focused id=2,1",
             ChangesToDescription1(*embed_connection->tracker()->changes())[0]);
   EXPECT_EQ("InputEvent view=2,1 event_action=4",
             ChangesToDescription1(*embed_connection->tracker()->changes())[1]);
 }
 
-}  // namespace mus
+}  // namespace view_manager