Revert of Mandoline UI Process: Update namespaces and file names

components/mus/connection_manager.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/connection_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/shared_quad_state.h"
 #include "components/mus/client_connection.h"
 #include "components/mus/connection_manager_delegate.h"
 #include "components/mus/server_view.h"
 #include "components/mus/view_coordinate_conversions.h"
 #include "components/mus/view_tree_host_connection.h"
 #include "components/mus/view_tree_impl.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
-namespace mus {
+using mojo::ConnectionSpecificId;
+
+namespace view_manager {
 
 ConnectionManager::ScopedChange::ScopedChange(
     ViewTreeImpl* connection,
     ConnectionManager* connection_manager,
     bool is_delete_view)
     : connection_manager_(connection_manager),
       connection_id_(connection->id()),
       is_delete_view_(is_delete_view) {
   connection_manager_->PrepareForChange(this);
 }
 
 ConnectionManager::ScopedChange::~ScopedChange() {
   connection_manager_->FinishChange();
 }
 
 ConnectionManager::ConnectionManager(
     ConnectionManagerDelegate* delegate,
-    const scoped_refptr<SurfacesState>& surfaces_state)
+    const scoped_refptr<surfaces::SurfacesState>& surfaces_state)
     : delegate_(delegate),
       surfaces_state_(surfaces_state),
       next_connection_id_(1),
       next_host_id_(0),
       current_change_(nullptr),
       in_destructor_(false) {}
 
 ConnectionManager::~ConnectionManager() {
   in_destructor_ = true;
 
@@ skipping 68 matching lines @@
   // observer pattern to do this. Each ViewTreeImpl should track its
   // parent's lifetime.
   host_connection_map_.erase(it);
   OnConnectionError(service_connection_it->second);
 
   // If we have no more roots left, let the app know so it can terminate.
   if (!host_connection_map_.size())
     delegate_->OnNoMoreRootConnections();
 }
 
-void ConnectionManager::EmbedAtView(ConnectionSpecificId creator_id,
+void ConnectionManager::EmbedAtView(mojo::ConnectionSpecificId creator_id,
                                     const ViewId& view_id,
                                     uint32_t policy_bitmask,
                                     mojo::URLRequestPtr request) {
   mojo::ViewTreePtr service_ptr;
   ClientConnection* client_connection =
       delegate_->CreateClientConnectionForEmbedAtView(
           this, GetProxy(&service_ptr), creator_id, request.Pass(), view_id,
           policy_bitmask);
   AddConnection(client_connection);
   client_connection->service()->Init(client_connection->client(),
                                      service_ptr.Pass());
   OnConnectionMessagedClient(client_connection->service()->id());
 }
 
-ViewTreeImpl* ConnectionManager::EmbedAtView(ConnectionSpecificId creator_id,
-                                             const ViewId& view_id,
-                                             uint32_t policy_bitmask,
-                                             mojo::ViewTreeClientPtr client) {
+ViewTreeImpl* ConnectionManager::EmbedAtView(
+    mojo::ConnectionSpecificId creator_id,
+    const ViewId& view_id,
+    uint32_t policy_bitmask,
+    mojo::ViewTreeClientPtr client) {
   mojo::ViewTreePtr service_ptr;
   ClientConnection* client_connection =
       delegate_->CreateClientConnectionForEmbedAtView(
           this, GetProxy(&service_ptr), creator_id, view_id, policy_bitmask,
           client.Pass());
   AddConnection(client_connection);
   client_connection->service()->Init(client_connection->client(),
                                      service_ptr.Pass());
   OnConnectionMessagedClient(client_connection->service()->id());
 
@@ skipping 166 matching lines @@
   DCHECK_EQ(0u, connection_map_.count(connection->service()->id()));
   connection_map_[connection->service()->id()] = connection;
 }
 
 scoped_ptr<cc::CompositorFrame>
 ConnectionManager::UpdateViewTreeFromCompositorFrame(
     const mojo::CompositorFramePtr& input) {
   return ConvertToCompositorFrame(input, this);
 }
 
-SurfacesState* ConnectionManager::GetSurfacesState() {
+surfaces::SurfacesState* ConnectionManager::GetSurfacesState() {
   return surfaces_state_.get();
 }
 
 void ConnectionManager::OnScheduleViewPaint(const ServerView* view) {
   if (!in_destructor_)
     SchedulePaint(view, gfx::Rect(view->bounds().size()));
 }
 
 const ServerView* ConnectionManager::GetRootView(const ServerView* view) const {
   const ViewTreeHostImpl* host = GetViewTreeHostByView(view);
@@ skipping 108 matching lines @@
   bounds.set_origin(p);
   // TODO(fsamuel): This seems like a crude way to set the size that probably
   // doesn't work correctly in the general case. We need to get transforms
   // working correctly in the general case.
   bounds.set_size(gfx::ToRoundedSize(
       gfx::ScaleSize(bounds.size(), metadata->device_scale_factor)));
   view->SetBounds(bounds);
   return true;
 }
 
-}  // namespace mus
+}  // namespace view_manager