Mandoline UI Process: Update namespaces and file names

components/mus/view_tree_impl.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/view_tree_impl.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "components/mus/connection_manager.h"
 #include "components/mus/default_access_policy.h"
 #include "components/mus/display_manager.h"
 #include "components/mus/server_view.h"
 #include "components/mus/view_tree_host_impl.h"
 #include "components/mus/window_manager_access_policy.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/ime/ime_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "ui/platform_window/text_input_state.h"
 
 using mojo::Array;
 using mojo::Callback;
-using mojo::Id;
 using mojo::InterfaceRequest;
 using mojo::OrderDirection;
 using mojo::Rect;
 using mojo::ServiceProvider;
 using mojo::ServiceProviderPtr;
 using mojo::String;
 using mojo::ViewDataPtr;
 
-namespace view_manager {
+namespace mus {
 
 ViewTreeImpl::ViewTreeImpl(ConnectionManager* connection_manager,
-                           mojo::ConnectionSpecificId creator_id,
+                           ConnectionSpecificId creator_id,
                            const ViewId& root_id)
     : connection_manager_(connection_manager),
       id_(connection_manager_->GetAndAdvanceNextConnectionId()),
       creator_id_(creator_id),
       client_(nullptr),
       is_embed_root_(false) {
   ServerView* view = GetView(root_id);
   CHECK(view);
   root_.reset(new ViewId(root_id));
   if (view->GetRoot() == view) {
@@ skipping 15 matching lines @@
   client_ = client;
   std::vector<const ServerView*> to_send;
   if (root_.get())
     GetUnknownViewsFrom(GetView(*root_), &to_send);
 
   // TODO(beng): verify that host can actually be nullptr here.
   ViewTreeHostImpl* host = GetHost();
   const ServerView* focused_view = host ? host->GetFocusedView() : nullptr;
   if (focused_view)
     focused_view = access_policy_->GetViewForFocusChange(focused_view);
-  const mojo::Id focused_view_transport_id(
+  const Id focused_view_transport_id(
       ViewIdToTransportId(focused_view ? focused_view->id() : ViewId()));
 
   client->OnEmbed(id_, ViewToViewData(to_send.front()), tree.Pass(),
                   focused_view_transport_id,
                   is_embed_root_ ? ViewTree::ACCESS_POLICY_EMBED_ROOT
                                  : ViewTree::ACCESS_POLICY_DEFAULT);
 }
 
 const ServerView* ViewTreeImpl::GetView(const ViewId& id) const {
   if (id_ == id.connection_id) {
@@ skipping 66 matching lines @@
       !access_policy_->CanChangeViewVisibility(view)) {
     return false;
   }
   ConnectionManager::ScopedChange change(this, connection_manager_, false);
   view->SetVisible(visible);
   return true;
 }
 
 bool ViewTreeImpl::Embed(const ViewId& view_id,
                          mojo::ViewTreeClientPtr client,
-                         mojo::ConnectionSpecificId* connection_id) {
+                         ConnectionSpecificId* connection_id) {
   *connection_id = kInvalidConnectionId;
   if (!client.get() || !CanEmbed(view_id))
     return false;
   PrepareForEmbed(view_id);
   ViewTreeImpl* new_connection =
       connection_manager_->EmbedAtView(id_, view_id, client.Pass());
   if (is_embed_root_)
     *connection_id = new_connection->id();
   return true;
 }
@@ skipping 427 matching lines @@
     if (value.is_null()) {
       view->SetProperty(name, nullptr);
     } else {
       std::vector<uint8_t> data = value.To<std::vector<uint8_t>>();
       view->SetProperty(name, &data);
     }
   }
   callback.Run(success);
 }
 
-void ViewTreeImpl::RequestSurface(mojo::Id view_id,
+void ViewTreeImpl::RequestSurface(Id view_id,
                                   mojo::InterfaceRequest<mojo::Surface> surface,
                                   mojo::SurfaceClientPtr client) {
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   const bool success = view && access_policy_->CanSetViewSurfaceId(view);
   if (!success)
     return;
   view->Bind(surface.Pass(), client.Pass());
 }
 
 void ViewTreeImpl::SetViewTextInputState(uint32_t view_id,
@@ skipping 28 matching lines @@
 
   ViewTreeImpl* existing_owner =
       connection_manager_->GetConnectionWithRoot(view_id);
   if (existing_owner)
     return;  // Only allow changing the access policy when nothing is embedded.
 
   if (access_policy_->CanSetAccessPolicy(view))
     view->set_pending_access_policy(policy_bitmask);
 }
 
-void ViewTreeImpl::Embed(mojo::Id transport_view_id,
+void ViewTreeImpl::Embed(Id transport_view_id,
                          mojo::ViewTreeClientPtr client,
                          const EmbedCallback& callback) {
-  mojo::ConnectionSpecificId connection_id = kInvalidConnectionId;
+  ConnectionSpecificId connection_id = kInvalidConnectionId;
   const bool result = Embed(ViewIdFromTransportId(transport_view_id),
                             client.Pass(), &connection_id);
   callback.Run(result, connection_id);
 }
 
 void ViewTreeImpl::SetFocus(uint32_t view_id) {
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   // TODO(beng): consider shifting non-policy drawn check logic to VTH's
   //             FocusController.
   if (view && view->IsDrawn() && access_policy_->CanSetFocus(view)) {
@@ skipping 16 matching lines @@
     const ServerView* view) const {
   ViewTreeImpl* connection =
       connection_manager_->GetConnectionWithRoot(view->id());
   return connection && connection != this;
 }
 
 bool ViewTreeImpl::IsDescendantOfEmbedRoot(const ServerView* view) {
   return is_embed_root_ && root_ && GetView(*root_)->Contains(view);
 }
 
-}  // namespace view_manager
+}  // namespace mus