Mandoline: Rename components/view_manager to components/mus

components/mus/public/cpp/lib/view_tree_client_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/public/cpp/lib/view_tree_client_impl.h"
+#include "components/mus/public/cpp/lib/view_tree_client_impl.h"
 
-#include "components/view_manager/public/cpp/lib/view_private.h"
-#include "components/view_manager/public/cpp/util.h"
-#include "components/view_manager/public/cpp/view_observer.h"
-#include "components/view_manager/public/cpp/view_tree_connection.h"
-#include "components/view_manager/public/cpp/view_tree_delegate.h"
+#include "components/mus/public/cpp/lib/view_private.h"
+#include "components/mus/public/cpp/util.h"
+#include "components/mus/public/cpp/view_observer.h"
+#include "components/mus/public/cpp/view_tree_connection.h"
+#include "components/mus/public/cpp/view_tree_delegate.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/connect.h"
 #include "mojo/application/public/cpp/service_provider_impl.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 
 namespace mojo {
 
 Id MakeTransportId(ConnectionSpecificId connection_id,
                    ConnectionSpecificId local_id) {
   return (connection_id << 16) | local_id;
@@ skipping 45 matching lines @@
   }
   return root;
 }
 
 ViewTreeConnection* ViewTreeConnection::Create(
     ViewTreeDelegate* delegate,
     InterfaceRequest<ViewTreeClient> request) {
   return new ViewTreeClientImpl(delegate, request.Pass());
 }
 
-ViewTreeClientImpl::ViewTreeClientImpl(
-    ViewTreeDelegate* delegate,
-    InterfaceRequest<ViewTreeClient> request)
+ViewTreeClientImpl::ViewTreeClientImpl(ViewTreeDelegate* delegate,
+                                       InterfaceRequest<ViewTreeClient> request)
     : connection_id_(0),
       next_id_(1),
       delegate_(delegate),
       root_(nullptr),
       capture_view_(nullptr),
       focused_view_(nullptr),
       activated_view_(nullptr),
       binding_(this, request.Pass()),
       is_embed_root_(false),
-      in_destructor_(false) {
-}
+      in_destructor_(false) {}
 
 ViewTreeClientImpl::~ViewTreeClientImpl() {
   in_destructor_ = true;
 
   std::vector<View*> non_owned;
   while (!views_.empty()) {
     IdToViewMap::iterator it = views_.begin();
     if (OwnsView(it->second->id())) {
       it->second->Destroy();
     } else {
@@ skipping 20 matching lines @@
 void ViewTreeClientImpl::AddChild(Id child_id, Id parent_id) {
   DCHECK(tree_);
   tree_->AddView(parent_id, child_id, ActionCompletedCallback());
 }
 
 void ViewTreeClientImpl::RemoveChild(Id child_id, Id parent_id) {
   DCHECK(tree_);
   tree_->RemoveViewFromParent(child_id, ActionCompletedCallback());
 }
 
-void ViewTreeClientImpl::Reorder(
-    Id view_id,
-    Id relative_view_id,
-    OrderDirection direction) {
+void ViewTreeClientImpl::Reorder(Id view_id,
+                                 Id relative_view_id,
+                                 OrderDirection direction) {
   DCHECK(tree_);
   tree_->ReorderView(view_id, relative_view_id, direction,
                      ActionCompletedCallback());
 }
 
 bool ViewTreeClientImpl::OwnsView(Id id) const {
   return HiWord(id) == connection_id_;
 }
 
 void ViewTreeClientImpl::SetBounds(Id view_id, const Rect& bounds) {
   DCHECK(tree_);
   tree_->SetViewBounds(view_id, bounds.Clone(), ActionCompletedCallback());
 }
 
 void ViewTreeClientImpl::SetFocus(Id view_id) {
   // In order for us to get here we had to have exposed a view, which implies we
   // got a connection.
   DCHECK(tree_);
   tree_->SetFocus(view_id);
 }
 
 void ViewTreeClientImpl::SetVisible(Id view_id, bool visible) {
   DCHECK(tree_);
   tree_->SetViewVisibility(view_id, visible, ActionCompletedCallback());
 }
 
-void ViewTreeClientImpl::SetProperty(
-    Id view_id,
-    const std::string& name,
-    const std::vector<uint8_t>& data) {
+void ViewTreeClientImpl::SetProperty(Id view_id,
+                                     const std::string& name,
+                                     const std::vector<uint8_t>& data) {
   DCHECK(tree_);
-  tree_->SetViewProperty(view_id,
-                         String(name),
-                         Array<uint8_t>::From(data),
+  tree_->SetViewProperty(view_id, String(name), Array<uint8_t>::From(data),
                          ActionCompletedCallback());
 }
 
 void ViewTreeClientImpl::SetViewTextInputState(Id view_id,
                                                TextInputStatePtr state) {
   DCHECK(tree_);
   tree_->SetViewTextInputState(view_id, state.Pass());
 }
 
 void ViewTreeClientImpl::SetImeVisibility(Id view_id,
@@ skipping 148 matching lines @@
   View* view = GetRoot();
   if (view)
     SetViewportMetricsOnDecendants(view, *old_metrics, *new_metrics);
 }
 
 void ViewTreeClientImpl::OnViewHierarchyChanged(
     Id view_id,
     Id new_parent_id,
     Id old_parent_id,
     mojo::Array<ViewDataPtr> views) {
-  View* initial_parent = views.size() ?
-      GetViewById(views[0]->parent_id) : NULL;
+  View* initial_parent = views.size() ? GetViewById(views[0]->parent_id) : NULL;
 
   const bool was_view_known = GetViewById(view_id) != nullptr;
 
   BuildViewTree(this, views, initial_parent);
 
   // If the view was not known, then BuildViewTree() will have created it and
   // parented the view.
   if (!was_view_known)
     return;
 
@@ skipping 29 matching lines @@
   if (view)
     ViewPrivate(view).LocalSetVisible(visible);
 }
 
 void ViewTreeClientImpl::OnViewDrawnStateChanged(Id view_id, bool drawn) {
   View* view = GetViewById(view_id);
   if (view)
     ViewPrivate(view).LocalSetDrawn(drawn);
 }
 
-void ViewTreeClientImpl::OnViewSharedPropertyChanged(
-    Id view_id,
-    const String& name,
-    Array<uint8_t> new_data) {
+void ViewTreeClientImpl::OnViewSharedPropertyChanged(Id view_id,
+                                                     const String& name,
+                                                     Array<uint8_t> new_data) {
   View* view = GetViewById(view_id);
   if (view) {
     std::vector<uint8_t> data;
     std::vector<uint8_t>* data_ptr = NULL;
     if (!new_data.is_null()) {
       data = new_data.To<std::vector<uint8_t>>();
       data_ptr = &data;
     }
 
     view->SetSharedProperty(name, data_ptr);
   }
 }
 
 void ViewTreeClientImpl::OnViewInputEvent(
     Id view_id,
     EventPtr event,
     const Callback<void()>& ack_callback) {
   View* view = GetViewById(view_id);
   if (view) {
-    FOR_EACH_OBSERVER(ViewObserver,
-                      *ViewPrivate(view).observers(),
+    FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(view).observers(),
                       OnViewInputEvent(view, event));
   }
   ack_callback.Run();
 }
 
 void ViewTreeClientImpl::OnViewFocused(Id focused_view_id) {
   View* focused = GetViewById(focused_view_id);
   View* blurred = focused_view_;
   // Update |focused_view_| before calling any of the observers, so that the
   // observers get the correct result from calling |View::HasFocus()|,
@@ skipping 15 matching lines @@
 void ViewTreeClientImpl::OnActionCompleted(bool success) {
   if (!change_acked_callback_.is_null())
     change_acked_callback_.Run();
 }
 
 Callback<void(bool)> ViewTreeClientImpl::ActionCompletedCallback() {
   return [this](bool success) { OnActionCompleted(success); };
 }
 
 }  // namespace mojo