Rename ViewManagerService,ViewManagerClient -> ViewTree,ViewTreeClient

components/view_manager/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/view_manager/connection_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "components/view_manager/client_connection.h"
 #include "components/view_manager/connection_manager_delegate.h"
 #include "components/view_manager/focus_controller.h"
 #include "components/view_manager/server_view.h"
 #include "components/view_manager/view_coordinate_conversions.h"
 #include "components/view_manager/view_manager_root_connection.h"
-#include "components/view_manager/view_manager_service_impl.h"
+#include "components/view_manager/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"
 
 using mojo::ConnectionSpecificId;
 
 namespace view_manager {
 namespace {
 
 // Creates a copy of |view|. The copied view has |delegate| as its delegate.
@@ skipping 64 matching lines @@
   for (ServerView* child : view->GetChildren()) {
     if (DecrementAnimatingViewsOpacity(child))
       ret_value = true;
   }
   return ret_value;
 }
 
 }  // namespace
 
 ConnectionManager::ScopedChange::ScopedChange(
-    ViewManagerServiceImpl* connection,
+    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();
@@ skipping 53 matching lines @@
   const uint16_t id = next_root_id_++;
   DCHECK_LT(id, next_root_id_);
   return id;
 }
 
 void ConnectionManager::OnConnectionError(ClientConnection* connection) {
   // This will be null if the root has been destroyed.
   const ViewId* view_id = connection->service()->root();
   ServerView* view =
       view_id ? GetView(*connection->service()->root()) : nullptr;
-  // If the ViewManagerService root is a viewport root, then we'll wait until
+  // If the ViewTree root is a viewport root, then we'll wait until
   // the root connection goes away to cleanup.
   if (view && (GetRootView(view) == view))
     return;
 
   scoped_ptr<ClientConnection> connection_owner(connection);
 
   connection_map_.erase(connection->service()->id());
 
   // TODO(sky): I may want to advance focus differently if focus is in
   // |connection|.
 
   // Notify remaining connections so that they can cleanup.
   for (auto& pair : connection_map_) {
-    pair.second->service()->OnWillDestroyViewManagerServiceImpl(
+    pair.second->service()->OnWillDestroyViewTreeImpl(
         connection->service());
   }
 }
 
 void ConnectionManager::OnRootConnectionClosed(
     ViewManagerRootConnection* connection) {
   auto it = root_connection_map_.find(connection->view_manager_root());
   DCHECK(it != root_connection_map_.end());
 
   // Clear focus if the focused view is in this viewport.
   if (GetRootView(GetFocusedView()) == it->first->root_view())
     SetFocusedView(nullptr);
 
-  // Get the ClientConnection by ViewManagerServiceImpl ID.
+  // Get the ClientConnection by ViewTreeImpl ID.
   ConnectionMap::iterator service_connection_it =
-      connection_map_.find(it->first->GetViewManagerService()->id());
+      connection_map_.find(it->first->GetViewTree()->id());
   DCHECK(service_connection_it != connection_map_.end());
 
-  //  Tear down the associated ViewManagerService connection.
+  // Tear down the associated ViewTree connection.
   // TODO(fsamuel): I don't think this is quite right, we should tear down all
   // connections within the root's viewport. We should probably employ an
-  // observer pattern to do this. Each ViewManagerServiceImpl should track its
+  // observer pattern to do this. Each ViewTreeImpl should track its
   // parent's lifetime.
   root_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 (!root_connection_map_.size())
     delegate_->OnNoMoreRootConnections();
 }
 
 void ConnectionManager::EmbedAtView(mojo::ConnectionSpecificId creator_id,
                                     const ViewId& view_id,
                                     mojo::URLRequestPtr request) {
-  mojo::ViewManagerServicePtr service_ptr;
+  mojo::ViewTreePtr service_ptr;
   ClientConnection* client_connection =
       delegate_->CreateClientConnectionForEmbedAtView(
           this, GetProxy(&service_ptr), creator_id, request.Pass(), view_id);
   AddConnection(client_connection);
   client_connection->service()->Init(client_connection->client(),
                                      service_ptr.Pass());
   OnConnectionMessagedClient(client_connection->service()->id());
 }
 
-ViewManagerServiceImpl* ConnectionManager::EmbedAtView(
+ViewTreeImpl* ConnectionManager::EmbedAtView(
     mojo::ConnectionSpecificId creator_id,
     const ViewId& view_id,
-    mojo::ViewManagerClientPtr client) {
-  mojo::ViewManagerServicePtr service_ptr;
+    mojo::ViewTreeClientPtr client) {
+  mojo::ViewTreePtr service_ptr;
   ClientConnection* client_connection =
       delegate_->CreateClientConnectionForEmbedAtView(
           this, GetProxy(&service_ptr), creator_id, view_id, client.Pass());
   AddConnection(client_connection);
   client_connection->service()->Init(client_connection->client(),
                                      service_ptr.Pass());
   OnConnectionMessagedClient(client_connection->service()->id());
 
   return client_connection->service();
 }
 
 void ConnectionManager::OnAccelerator(ServerView* root, mojo::EventPtr event) {
   for (auto& pair : root_connection_map_) {
     if (root == pair.first->root_view()) {
       pair.first->client()->OnAccelerator(event.Pass());
       return;
     }
   }
 }
 
-ViewManagerServiceImpl* ConnectionManager::GetConnection(
+ViewTreeImpl* ConnectionManager::GetConnection(
     ConnectionSpecificId connection_id) {
   ConnectionMap::iterator i = connection_map_.find(connection_id);
   return i == connection_map_.end() ? nullptr : i->second->service();
 }
 
 ServerView* ConnectionManager::GetView(const ViewId& id) {
   for (auto& pair : root_connection_map_) {
     if (pair.first->root_view()->id() == id)
       return pair.first->root_view();
   }
-  ViewManagerServiceImpl* service = GetConnection(id.connection_id);
+  ViewTreeImpl* service = GetConnection(id.connection_id);
   return service ? service->GetView(id) : nullptr;
 }
 
 void ConnectionManager::SetFocusedView(ServerView* view) {
   if (!focus_controller_)
     return;
   ServerView* old_focused = GetFocusedView();
   if (old_focused == view)
     return;
   focus_controller_->SetFocusedView(view);
@@ skipping 39 matching lines @@
     return view_manager_root->GetViewportMetrics().Clone();
 
   if (!root_connection_map_.empty())
     return root_connection_map_.begin()->first->GetViewportMetrics().Clone();
 
   mojo::ViewportMetricsPtr metrics = mojo::ViewportMetrics::New();
   metrics->size_in_pixels = mojo::Size::New();
   return metrics.Pass();
 }
 
-const ViewManagerServiceImpl* ConnectionManager::GetConnectionWithRoot(
+const ViewTreeImpl* ConnectionManager::GetConnectionWithRoot(
     const ViewId& id) const {
   for (auto& pair : connection_map_) {
     if (pair.second->service()->IsRoot(id))
       return pair.second->service();
   }
   return nullptr;
 }
 
-ViewManagerServiceImpl* ConnectionManager::GetEmbedRoot(
-    ViewManagerServiceImpl* service) {
+ViewTreeImpl* ConnectionManager::GetEmbedRoot(ViewTreeImpl* service) {
   while (service) {
     const ViewId* root_id = service->root();
     if (!root_id || root_id->connection_id == service->id())
       return nullptr;
 
-    ViewManagerServiceImpl* parent_service =
-        GetConnection(root_id->connection_id);
+    ViewTreeImpl* parent_service = GetConnection(root_id->connection_id);
     service = parent_service;
     if (service && service->is_embed_root())
       return service;
   }
   return nullptr;
 }
 
 bool ConnectionManager::CloneAndAnimate(const ViewId& view_id) {
   ServerView* view = GetView(view_id);
   if (!view || !view->IsDrawn() || (view->GetRoot() == view))
     return false;
   if (!animation_timer_.IsRunning()) {
     animation_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(100),
                            this, &ConnectionManager::DoAnimation);
   }
   ServerView* clone = CloneView(view, this);
   CloneViewTree(view, clone, this);
   view->parent()->Add(clone);
   view->parent()->Reorder(clone, view, mojo::ORDER_DIRECTION_ABOVE);
   return true;
 }
 
 void ConnectionManager::DispatchInputEventToView(const ServerView* view,
                                                  mojo::EventPtr event) {
   // If the view is an embed root, forward to the embedded view, not the owner.
-  ViewManagerServiceImpl* connection = GetConnectionWithRoot(view->id());
+  ViewTreeImpl* connection = GetConnectionWithRoot(view->id());
   if (!connection)
     connection = GetConnection(view->id().connection_id);
   CHECK(connection);
   connection->client()->OnViewInputEvent(ViewIdToTransportId(view->id()),
                                          event.Pass(),
                                          base::Bind(&base::DoNothing));
 }
 
 void ConnectionManager::OnEvent(ViewManagerRootImpl* root,
                                 mojo::EventPtr event) {
@@ skipping 267 matching lines @@
 
 void ConnectionManager::OnFocusChanged(ServerView* old_focused_view,
                                        ServerView* new_focused_view) {
   // There are up to four connections that need to be notified:
   // . the connection containing |old_focused_view|.
   // . the connection with |old_focused_view| as its root.
   // . the connection containing |new_focused_view|.
   // . the connection with |new_focused_view| as its root.
   // Some of these connections may be the same. The following takes care to
   // notify each only once.
-  ViewManagerServiceImpl* owning_connection_old = nullptr;
-  ViewManagerServiceImpl* embedded_connection_old = nullptr;
+  ViewTreeImpl* owning_connection_old = nullptr;
+  ViewTreeImpl* embedded_connection_old = nullptr;
 
   if (old_focused_view) {
     owning_connection_old = GetConnection(old_focused_view->id().connection_id);
     if (owning_connection_old) {
       owning_connection_old->ProcessFocusChanged(old_focused_view,
                                                  new_focused_view);
     }
     embedded_connection_old = GetConnectionWithRoot(old_focused_view->id());
     if (embedded_connection_old) {
       DCHECK_NE(owning_connection_old, embedded_connection_old);
       embedded_connection_old->ProcessFocusChanged(old_focused_view,
                                                    new_focused_view);
     }
   }
-  ViewManagerServiceImpl* owning_connection_new = nullptr;
-  ViewManagerServiceImpl* embedded_connection_new = nullptr;
+  ViewTreeImpl* owning_connection_new = nullptr;
+  ViewTreeImpl* embedded_connection_new = nullptr;
   if (new_focused_view) {
     owning_connection_new = GetConnection(new_focused_view->id().connection_id);
     if (owning_connection_new &&
         owning_connection_new != owning_connection_old &&
         owning_connection_new != embedded_connection_old) {
       owning_connection_new->ProcessFocusChanged(old_focused_view,
                                                  new_focused_view);
     }
     embedded_connection_new = GetConnectionWithRoot(new_focused_view->id());
     if (embedded_connection_new &&
         embedded_connection_new != owning_connection_old &&
         embedded_connection_new != embedded_connection_old) {
       DCHECK_NE(owning_connection_new, embedded_connection_new);
       embedded_connection_new->ProcessFocusChanged(old_focused_view,
                                                    new_focused_view);
     }
   }
 
   for (auto& pair : root_connection_map_) {
-    ViewManagerServiceImpl* service = pair.first->GetViewManagerService();
+    ViewTreeImpl* service = pair.first->GetViewTree();
     if (service != owning_connection_old &&
         service != embedded_connection_old &&
         service != owning_connection_new &&
         service != embedded_connection_new) {
       service->ProcessFocusChanged(old_focused_view, new_focused_view);
     }
   }
 
   ViewManagerRootImpl* old_view_manager_root =
       old_focused_view ? GetViewManagerRootByView(old_focused_view) : nullptr;
 
   ViewManagerRootImpl* new_view_manager_root =
       new_focused_view ? GetViewManagerRootByView(new_focused_view) : nullptr;
 
   if (new_view_manager_root) {
     new_view_manager_root->UpdateTextInputState(
         new_focused_view->text_input_state());
   } else if (old_view_manager_root) {
     old_view_manager_root->UpdateTextInputState(ui::TextInputState());
   }
 }
 
 }  // namespace view_manager