Move //mojo/services/X/public/... to //mojo/services/X/... (part 4).

mojo/services/view_manager/cpp/lib/view_manager_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 "view_manager/public/cpp/lib/view_manager_client_impl.h"
+#include "view_manager/cpp/lib/view_manager_client_impl.h"
 
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
-#include "view_manager/public/cpp/lib/view_private.h"
-#include "view_manager/public/cpp/util.h"
-#include "view_manager/public/cpp/view_manager_delegate.h"
-#include "view_manager/public/cpp/view_observer.h"
+#include "view_manager/cpp/lib/view_private.h"
+#include "view_manager/cpp/util.h"
+#include "view_manager/cpp/view_manager_delegate.h"
+#include "view_manager/cpp/view_observer.h"
 
 namespace mojo {
 
 Id MakeTransportId(ConnectionSpecificId connection_id,
                    ConnectionSpecificId local_id) {
   return (connection_id << 16) | local_id;
 }
 
 // Helper called to construct a local view object from transport data.
 View* AddViewToViewManager(ViewManagerClientImpl* client,
@@ skipping 111 matching lines @@
 void ViewManagerClientImpl::AddChild(Id child_id, Id parent_id) {
   DCHECK(service_);
   service_->AddView(parent_id, child_id, ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::RemoveChild(Id child_id, Id parent_id) {
   DCHECK(service_);
   service_->RemoveViewFromParent(child_id, ActionCompletedCallback());
 }
 
-void ViewManagerClientImpl::Reorder(
-    Id view_id,
-    Id relative_view_id,
-    OrderDirection direction) {
+void ViewManagerClientImpl::Reorder(Id view_id,
+                                    Id relative_view_id,
+                                    OrderDirection direction) {
   DCHECK(service_);
   service_->ReorderView(view_id, relative_view_id, direction,
                         ActionCompletedCallback());
 }
 
 bool ViewManagerClientImpl::OwnsView(Id id) const {
   return HiWord(id) == connection_id_;
 }
 
 void ViewManagerClientImpl::SetBounds(Id view_id, const Rect& bounds) {
   DCHECK(service_);
   service_->SetViewBounds(view_id, bounds.Clone(), ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::SetSurfaceId(Id view_id, SurfaceIdPtr surface_id) {
   DCHECK(service_);
   if (surface_id.is_null())
     return;
-  service_->SetViewSurfaceId(
-      view_id, surface_id.Pass(), ActionCompletedCallback());
+  service_->SetViewSurfaceId(view_id, surface_id.Pass(),
+                             ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::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(service_);
   service_->PerformAction(view_id, "focus", ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::SetVisible(Id view_id, bool visible) {
   DCHECK(service_);
   service_->SetViewVisibility(view_id, visible, ActionCompletedCallback());
 }
 
-void ViewManagerClientImpl::SetProperty(
-    Id view_id,
-    const std::string& name,
-    const std::vector<uint8_t>& data) {
+void ViewManagerClientImpl::SetProperty(Id view_id,
+                                        const std::string& name,
+                                        const std::vector<uint8_t>& data) {
   DCHECK(service_);
-  service_->SetViewProperty(view_id,
-                            String(name),
-                            Array<uint8_t>::From(data),
+  service_->SetViewProperty(view_id, String(name), Array<uint8_t>::From(data),
                             ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::Embed(const String& url, Id view_id) {
   Embed(url, view_id, nullptr, nullptr);
 }
 
 void ViewManagerClientImpl::Embed(const String& url,
                                   Id view_id,
                                   InterfaceRequest<ServiceProvider> services,
@@ skipping 143 matching lines @@
   View* view = GetRoot();
   if (view)
     SetViewportMetricsOnDecendants(view, *old_metrics, *new_metrics);
 }
 
 void ViewManagerClientImpl::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;
 
   BuildViewTree(this, views, initial_parent);
 
   View* new_parent = GetViewById(new_parent_id);
   View* old_parent = GetViewById(old_parent_id);
   View* view = GetViewById(view_id);
   if (new_parent)
     ViewPrivate(new_parent).LocalAddChild(view);
   else
     ViewPrivate(old_parent).LocalRemoveChild(view);
@@ skipping 45 matching lines @@
     view->SetSharedProperty(name, data_ptr);
   }
 }
 
 void ViewManagerClientImpl::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 ViewManagerClientImpl::OnPerformAction(
     Id view_id,
     const String& name,
     const Callback<void(bool)>& callback) {
   View* view = GetViewById(view_id);
   callback.Run(delegate_->OnPerformAction(view, name));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, WindowManagerObserver implementation:
 
 void ViewManagerClientImpl::OnCaptureChanged(Id capture_view_id) {
   View* gained_capture = GetViewById(capture_view_id);
   View* lost_capture = capture_view_;
   if (lost_capture) {
-    FOR_EACH_OBSERVER(ViewObserver,
-                      *ViewPrivate(lost_capture).observers(),
+    FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(lost_capture).observers(),
                       OnViewFocusChanged(gained_capture, lost_capture));
   }
   capture_view_ = gained_capture;
   if (gained_capture) {
-    FOR_EACH_OBSERVER(ViewObserver,
-                      *ViewPrivate(gained_capture).observers(),
+    FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(gained_capture).observers(),
                       OnViewFocusChanged(gained_capture, lost_capture));
   }
 }
 
 void ViewManagerClientImpl::OnFocusChanged(Id focused_view_id) {
   View* focused = GetViewById(focused_view_id);
   View* blurred = focused_view_;
   if (blurred) {
-    FOR_EACH_OBSERVER(ViewObserver,
-                      *ViewPrivate(blurred).observers(),
+    FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(blurred).observers(),
                       OnViewFocusChanged(focused, blurred));
   }
   focused_view_ = focused;
   if (focused) {
-    FOR_EACH_OBSERVER(ViewObserver,
-                      *ViewPrivate(focused).observers(),
+    FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(focused).observers(),
                       OnViewFocusChanged(focused, blurred));
   }
 }
 
 void ViewManagerClientImpl::OnActiveWindowChanged(Id active_view_id) {
   View* activated = GetViewById(active_view_id);
   View* deactivated = activated_view_;
   if (deactivated) {
-    FOR_EACH_OBSERVER(ViewObserver,
-                      *ViewPrivate(deactivated).observers(),
+    FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(deactivated).observers(),
                       OnViewActivationChanged(activated, deactivated));
   }
   activated_view_ = activated;
   if (activated) {
-    FOR_EACH_OBSERVER(ViewObserver,
-                      *ViewPrivate(activated).observers(),
+    FOR_EACH_OBSERVER(ViewObserver, *ViewPrivate(activated).observers(),
                       OnViewActivationChanged(activated, deactivated));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, private:
 
 void ViewManagerClientImpl::RootDestroyed(View* root) {
   DCHECK_EQ(root, root_);
   root_ = nullptr;
 }
 
 void ViewManagerClientImpl::OnActionCompleted(bool success) {
   if (!change_acked_callback_.is_null())
     change_acked_callback_.Run();
 }
 
 Callback<void(bool)> ViewManagerClientImpl::ActionCompletedCallback() {
   return [this](bool success) { OnActionCompleted(success); };
 }
 
 }  // namespace mojo