Mandoline: Rename components/view_manager to components/mus

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/view_manager/view_tree_impl.h"
+#include "components/mus/view_tree_impl.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
-#include "components/view_manager/connection_manager.h"
-#include "components/view_manager/default_access_policy.h"
-#include "components/view_manager/display_manager.h"
-#include "components/view_manager/server_view.h"
-#include "components/view_manager/view_tree_host_impl.h"
-#include "components/view_manager/window_manager_access_policy.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 {
 
-ViewTreeImpl::ViewTreeImpl(
-    ConnectionManager* connection_manager,
-    mojo::ConnectionSpecificId creator_id,
-    const ViewId& root_id)
+ViewTreeImpl::ViewTreeImpl(ConnectionManager* connection_manager,
+                           mojo::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) {
     access_policy_.reset(new WindowManagerAccessPolicy(id_, this));
@@ skipping 36 matching lines @@
     return i == view_map_.end() ? NULL : i->second;
   }
   return connection_manager_->GetView(id);
 }
 
 bool ViewTreeImpl::IsRoot(const ViewId& id) const {
   return root_.get() && *root_ == id;
 }
 
 ViewTreeHostImpl* ViewTreeImpl::GetHost() {
-  return root_.get() ?
-      connection_manager_->GetViewTreeHostByView(GetView(*root_)) : nullptr;
+  return root_.get()
+             ? connection_manager_->GetViewTreeHostByView(GetView(*root_))
+             : nullptr;
 }
 
-void ViewTreeImpl::OnWillDestroyViewTreeImpl(
-    ViewTreeImpl* connection) {
+void ViewTreeImpl::OnWillDestroyViewTreeImpl(ViewTreeImpl* connection) {
   if (creator_id_ == connection->id())
     creator_id_ = kInvalidConnectionId;
   const ServerView* connection_root =
       connection->root_ ? connection->GetView(*connection->root_) : nullptr;
   if (connection_root &&
       ((connection_root->id().connection_id == id_ &&
         view_map_.count(connection_root->id().view_id) > 0) ||
        (is_embed_root_ && IsViewKnown(connection_root)))) {
     client()->OnEmbeddedAppDisconnected(
         ViewIdToTransportId(*connection->root_));
@@ skipping 58 matching lines @@
   return true;
 }
 
 void ViewTreeImpl::Embed(const ViewId& view_id, mojo::URLRequestPtr request) {
   if (!CanEmbed(view_id))
     return;
   PrepareForEmbed(view_id);
   connection_manager_->EmbedAtView(id_, view_id, request.Pass());
 }
 
-void ViewTreeImpl::ProcessViewBoundsChanged(
-    const ServerView* view,
-    const gfx::Rect& old_bounds,
-    const gfx::Rect& new_bounds,
-    bool originated_change) {
+void ViewTreeImpl::ProcessViewBoundsChanged(const ServerView* view,
+                                            const gfx::Rect& old_bounds,
+                                            const gfx::Rect& new_bounds,
+                                            bool originated_change) {
   if (originated_change || !IsViewKnown(view))
     return;
   client()->OnViewBoundsChanged(ViewIdToTransportId(view->id()),
-                                Rect::From(old_bounds),
-                                Rect::From(new_bounds));
+                                Rect::From(old_bounds), Rect::From(new_bounds));
 }
 
 void ViewTreeImpl::ProcessViewportMetricsChanged(
     const mojo::ViewportMetrics& old_metrics,
     const mojo::ViewportMetrics& new_metrics,
     bool originated_change) {
   client()->OnViewViewportMetricsChanged(old_metrics.Clone(),
                                          new_metrics.Clone());
 }
 
-void ViewTreeImpl::ProcessWillChangeViewHierarchy(
-    const ServerView* view,
-    const ServerView* new_parent,
-    const ServerView* old_parent,
-    bool originated_change) {
+void ViewTreeImpl::ProcessWillChangeViewHierarchy(const ServerView* view,
+                                                  const ServerView* new_parent,
+                                                  const ServerView* old_parent,
+                                                  bool originated_change) {
   if (originated_change)
     return;
 
   const bool old_drawn = view->IsDrawn();
   const bool new_drawn = view->visible() && new_parent && new_parent->IsDrawn();
   if (old_drawn == new_drawn)
     return;
 
   NotifyDrawnStateChanged(view, new_drawn);
 }
 
 void ViewTreeImpl::ProcessViewPropertyChanged(
     const ServerView* view,
     const std::string& name,
     const std::vector<uint8_t>* new_data,
     bool originated_change) {
   if (originated_change)
     return;
 
   Array<uint8_t> data;
   if (new_data)
     data = Array<uint8_t>::From(*new_data);
 
   client()->OnViewSharedPropertyChanged(ViewIdToTransportId(view->id()),
                                         String(name), data.Pass());
 }
 
-void ViewTreeImpl::ProcessViewHierarchyChanged(
-    const ServerView* view,
-    const ServerView* new_parent,
-    const ServerView* old_parent,
-    bool originated_change) {
+void ViewTreeImpl::ProcessViewHierarchyChanged(const ServerView* view,
+                                               const ServerView* new_parent,
+                                               const ServerView* old_parent,
+                                               bool originated_change) {
   if (originated_change && !IsViewKnown(view) && new_parent &&
       IsViewKnown(new_parent)) {
     std::vector<const ServerView*> unused;
     GetUnknownViewsFrom(view, &unused);
   }
   if (originated_change || connection_manager_->is_processing_delete_view() ||
       connection_manager_->DidConnectionMessageClient(id_)) {
     return;
   }
 
-  if (!access_policy_->ShouldNotifyOnHierarchyChange(
-          view, &new_parent, &old_parent)) {
+  if (!access_policy_->ShouldNotifyOnHierarchyChange(view, &new_parent,
+                                                     &old_parent)) {
     return;
   }
   // Inform the client of any new views and update the set of views we know
   // about.
   std::vector<const ServerView*> to_send;
   if (!IsViewKnown(view))
     GetUnknownViewsFrom(view, &to_send);
   const ViewId new_parent_id(new_parent ? new_parent->id() : ViewId());
   const ViewId old_parent_id(old_parent ? old_parent->id() : ViewId());
-  client()->OnViewHierarchyChanged(ViewIdToTransportId(view->id()),
-                                   ViewIdToTransportId(new_parent_id),
-                                   ViewIdToTransportId(old_parent_id),
-                                   ViewsToViewDatas(to_send));
+  client()->OnViewHierarchyChanged(
+      ViewIdToTransportId(view->id()), ViewIdToTransportId(new_parent_id),
+      ViewIdToTransportId(old_parent_id), ViewsToViewDatas(to_send));
   connection_manager_->OnConnectionMessagedClient(id_);
 }
 
 void ViewTreeImpl::ProcessViewReorder(const ServerView* view,
                                       const ServerView* relative_view,
                                       OrderDirection direction,
                                       bool originated_change) {
   if (originated_change || !IsViewKnown(view) || !IsViewKnown(relative_view))
     return;
 
@@ skipping 14 matching lines @@
 
   if (originated_change)
     return;
 
   if (in_known) {
     client()->OnViewDeleted(ViewIdToTransportId(view));
     connection_manager_->OnConnectionMessagedClient(id_);
   }
 }
 
-void ViewTreeImpl::ProcessWillChangeViewVisibility(
-    const ServerView* view,
-    bool originated_change) {
+void ViewTreeImpl::ProcessWillChangeViewVisibility(const ServerView* view,
+                                                   bool originated_change) {
   if (originated_change)
     return;
 
   if (IsViewKnown(view)) {
     client()->OnViewVisibilityChanged(ViewIdToTransportId(view->id()),
                                       !view->visible());
     return;
   }
 
   bool view_target_drawn_state;
   if (view->visible()) {
     // View is being hidden, won't be drawn.
     view_target_drawn_state = false;
   } else {
     // View is being shown. View will be drawn if its parent is drawn.
     view_target_drawn_state = view->parent() && view->parent()->IsDrawn();
   }
 
   NotifyDrawnStateChanged(view, view_target_drawn_state);
 }
 
-void ViewTreeImpl::ProcessFocusChanged(
-    const ServerView* old_focused_view,
-    const ServerView* new_focused_view) {
+void ViewTreeImpl::ProcessFocusChanged(const ServerView* old_focused_view,
+                                       const ServerView* new_focused_view) {
   const ServerView* view =
       new_focused_view ? access_policy_->GetViewForFocusChange(new_focused_view)
                        : nullptr;
   client()->OnViewFocused(view ? ViewIdToTransportId(view->id())
                                : ViewIdToTransportId(ViewId()));
 }
 
 bool ViewTreeImpl::IsViewKnown(const ServerView* view) const {
   return known_views_.count(ViewIdToTransportId(view->id())) > 0;
 }
@@ skipping 25 matching lines @@
 }
 
 bool ViewTreeImpl::DeleteViewImpl(ViewTreeImpl* source, ServerView* view) {
   DCHECK(view);
   DCHECK_EQ(view->id().connection_id, id_);
   ConnectionManager::ScopedChange change(source, connection_manager_, true);
   delete view;
   return true;
 }
 
-void ViewTreeImpl::GetUnknownViewsFrom(
-    const ServerView* view,
-    std::vector<const ServerView*>* views) {
+void ViewTreeImpl::GetUnknownViewsFrom(const ServerView* view,
+                                       std::vector<const ServerView*>* views) {
   if (IsViewKnown(view) || !access_policy_->CanGetViewTree(view))
     return;
   views->push_back(view);
   known_views_.insert(ViewIdToTransportId(view->id()));
   if (!access_policy_->CanDescendIntoViewForViewTree(view))
     return;
   std::vector<const ServerView*> children(view->GetChildren());
-  for (size_t i = 0 ; i < children.size(); ++i)
+  for (size_t i = 0; i < children.size(); ++i)
     GetUnknownViewsFrom(children[i], views);
 }
 
-void ViewTreeImpl::RemoveFromKnown(
-    const ServerView* view,
-    std::vector<ServerView*>* local_views) {
+void ViewTreeImpl::RemoveFromKnown(const ServerView* view,
+                                   std::vector<ServerView*>* local_views) {
   if (view->id().connection_id == id_) {
     if (local_views)
       local_views->push_back(GetView(view->id()));
     return;
   }
   known_views_.erase(ViewIdToTransportId(view->id()));
   std::vector<const ServerView*> children = view->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
     RemoveFromKnown(children[i], local_views);
 }
@@ skipping 53 matching lines @@
 
   if (!access_policy_->CanGetViewTree(view))
     return;
 
   views->push_back(view);
 
   if (!access_policy_->CanDescendIntoViewForViewTree(view))
     return;
 
   std::vector<const ServerView*> children(view->GetChildren());
-  for (size_t i = 0 ; i < children.size(); ++i)
+  for (size_t i = 0; i < children.size(); ++i)
     GetViewTreeImpl(children[i], views);
 }
 
 void ViewTreeImpl::NotifyDrawnStateChanged(const ServerView* view,
                                            bool new_drawn_value) {
   // Even though we don't know about view, it may be an ancestor of our root, in
   // which case the change may effect our roots drawn state.
   if (!root_.get())
     return;
 
@@ skipping 41 matching lines @@
 
 void ViewTreeImpl::RemoveChildrenAsPartOfEmbed(const ViewId& view_id) {
   ServerView* view = GetView(view_id);
   CHECK(view);
   CHECK(view->id().connection_id == view_id.connection_id);
   std::vector<ServerView*> children = view->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
     view->Remove(children[i]);
 }
 
-void ViewTreeImpl::CreateView(
-    Id transport_view_id,
-    const Callback<void(mojo::ErrorCode)>& callback) {
+void ViewTreeImpl::CreateView(Id transport_view_id,
+                              const Callback<void(mojo::ErrorCode)>& callback) {
   callback.Run(CreateView(ViewIdFromTransportId(transport_view_id)));
 }
 
-void ViewTreeImpl::DeleteView(
-    Id transport_view_id,
-    const Callback<void(bool)>& callback) {
+void ViewTreeImpl::DeleteView(Id transport_view_id,
+                              const Callback<void(bool)>& callback) {
   ServerView* view = GetView(ViewIdFromTransportId(transport_view_id));
   bool success = false;
   if (view && access_policy_->CanDeleteView(view)) {
     ViewTreeImpl* connection =
         connection_manager_->GetConnection(view->id().connection_id);
     success = connection && connection->DeleteViewImpl(this, view);
   }
   callback.Run(success);
 }
 
-void ViewTreeImpl::AddView(
-    Id parent_id,
-    Id child_id,
-    const Callback<void(bool)>& callback) {
+void ViewTreeImpl::AddView(Id parent_id,
+                           Id child_id,
+                           const Callback<void(bool)>& callback) {
   callback.Run(AddView(ViewIdFromTransportId(parent_id),
                        ViewIdFromTransportId(child_id)));
 }
 
-void ViewTreeImpl::RemoveViewFromParent(
-    Id view_id,
-    const Callback<void(bool)>& callback) {
+void ViewTreeImpl::RemoveViewFromParent(Id view_id,
+                                        const Callback<void(bool)>& callback) {
   bool success = false;
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   if (view && view->parent() && access_policy_->CanRemoveViewFromParent(view)) {
     success = true;
     ConnectionManager::ScopedChange change(this, connection_manager_, false);
     view->parent()->Remove(view);
   }
   callback.Run(success);
 }
 
@@ skipping 14 matching lines @@
 }
 
 void ViewTreeImpl::GetViewTree(
     Id view_id,
     const Callback<void(Array<ViewDataPtr>)>& callback) {
   std::vector<const ServerView*> views(
       GetViewTree(ViewIdFromTransportId(view_id)));
   callback.Run(ViewsToViewDatas(views));
 }
 
-void ViewTreeImpl::SetViewBounds(
-    Id view_id,
-    mojo::RectPtr bounds,
-    const Callback<void(bool)>& callback) {
+void ViewTreeImpl::SetViewBounds(Id view_id,
+                                 mojo::RectPtr bounds,
+                                 const Callback<void(bool)>& callback) {
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   const bool success = view && access_policy_->CanSetViewBounds(view);
   if (success) {
     ConnectionManager::ScopedChange change(this, connection_manager_, false);
     view->SetBounds(bounds.To<gfx::Rect>());
   }
   callback.Run(success);
 }
 
-void ViewTreeImpl::SetViewVisibility(
-    Id transport_view_id,
-    bool visible,
-    const Callback<void(bool)>& callback) {
+void ViewTreeImpl::SetViewVisibility(Id transport_view_id,
+                                     bool visible,
+                                     const Callback<void(bool)>& callback) {
   callback.Run(
       SetViewVisibility(ViewIdFromTransportId(transport_view_id), visible));
 }
 
-void ViewTreeImpl::SetViewProperty(
-    uint32_t view_id,
-    const mojo::String& name,
-    mojo::Array<uint8_t> value,
-    const mojo::Callback<void(bool)>& callback) {
+void ViewTreeImpl::SetViewProperty(uint32_t view_id,
+                                   const mojo::String& name,
+                                   mojo::Array<uint8_t> value,
+                                   const mojo::Callback<void(bool)>& callback) {
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   const bool success = view && access_policy_->CanSetViewProperties(view);
   if (success) {
     ConnectionManager::ScopedChange change(this, connection_manager_, false);
 
     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,
-    mojo::InterfaceRequest<mojo::Surface> surface,
-    mojo::SurfaceClientPtr client) {
+void ViewTreeImpl::RequestSurface(mojo::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,
-    mojo::TextInputStatePtr state) {
+void ViewTreeImpl::SetViewTextInputState(uint32_t view_id,
+                                         mojo::TextInputStatePtr state) {
   ServerView* view = GetView(ViewIdFromTransportId(view_id));
   bool success = view && access_policy_->CanSetViewTextInputState(view);
   if (success)
     view->SetTextInputState(state.To<ui::TextInputState>());
 }
 
 void ViewTreeImpl::SetImeVisibility(Id transport_view_id,
                                     bool visible,
                                     mojo::TextInputStatePtr state) {
   ServerView* view = GetView(ViewIdFromTransportId(transport_view_id));
@@ skipping 58 matching lines @@
   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