components/mus/public/interfaces View => Window

components/mus/ws/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/mus/ws/connection_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "components/mus/ws/client_connection.h"
 #include "components/mus/ws/connection_manager_delegate.h"
@@ skipping 91 matching lines @@
   }
 }
 
 void ConnectionManager::OnHostConnectionClosed(
     ViewTreeHostConnection* connection) {
   auto it = host_connection_map_.find(connection->view_tree_host());
   DCHECK(it != host_connection_map_.end());
 
   // Get the ClientConnection by ViewTreeImpl ID.
   ConnectionMap::iterator service_connection_it =
-      connection_map_.find(it->first->GetViewTree()->id());
+      connection_map_.find(it->first->GetWindowTree()->id());
   DCHECK(service_connection_it != connection_map_.end());
 
   // 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 ViewTreeImpl should track its
   // parent's lifetime.
   host_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 (!host_connection_map_.size())
     delegate_->OnNoMoreRootConnections();
 }
 
 void ConnectionManager::EmbedAtView(ConnectionSpecificId creator_id,
                                     const ViewId& view_id,
                                     uint32_t policy_bitmask,
                                     mojo::URLRequestPtr request) {
-  mojo::ViewTreePtr service_ptr;
+  mojom::WindowTreePtr service_ptr;
   ClientConnection* client_connection =
       delegate_->CreateClientConnectionForEmbedAtView(
           this, GetProxy(&service_ptr), creator_id, request.Pass(), view_id,
           policy_bitmask);
   AddConnection(client_connection);
   client_connection->service()->Init(client_connection->client(),
                                      service_ptr.Pass());
   OnConnectionMessagedClient(client_connection->service()->id());
 }
 
-ViewTreeImpl* ConnectionManager::EmbedAtView(ConnectionSpecificId creator_id,
-                                             const ViewId& view_id,
-                                             uint32_t policy_bitmask,
-                                             mojo::ViewTreeClientPtr client) {
-  mojo::ViewTreePtr service_ptr;
+ViewTreeImpl* ConnectionManager::EmbedAtView(
+    ConnectionSpecificId creator_id,
+    const ViewId& view_id,
+    uint32_t policy_bitmask,
+    mojom::WindowTreeClientPtr client) {
+  mojom::WindowTreePtr service_ptr;
   ClientConnection* client_connection =
       delegate_->CreateClientConnectionForEmbedAtView(
           this, GetProxy(&service_ptr), creator_id, view_id, policy_bitmask,
           client.Pass());
   AddConnection(client_connection);
   client_connection->service()->Init(client_connection->client(),
                                      service_ptr.Pass());
   OnConnectionMessagedClient(client_connection->service()->id());
 
   return client_connection->service();
@@ skipping 33 matching lines @@
 void ConnectionManager::OnConnectionMessagedClient(ConnectionSpecificId id) {
   if (current_change_)
     current_change_->MarkConnectionAsMessaged(id);
 }
 
 bool ConnectionManager::DidConnectionMessageClient(
     ConnectionSpecificId id) const {
   return current_change_ && current_change_->DidMessageConnection(id);
 }
 
-mojo::ViewportMetricsPtr ConnectionManager::GetViewportMetricsForView(
+mojom::ViewportMetricsPtr ConnectionManager::GetViewportMetricsForView(
     const ServerView* view) {
-  ViewTreeHostImpl* host = GetViewTreeHostByView(view);
+  ViewTreeHostImpl* host = GetWindowTreeHostByView(view);
   if (host)
     return host->GetViewportMetrics().Clone();
 
   if (!host_connection_map_.empty())
     return host_connection_map_.begin()->first->GetViewportMetrics().Clone();
 
-  mojo::ViewportMetricsPtr metrics = mojo::ViewportMetrics::New();
+  mojom::ViewportMetricsPtr metrics = mojom::ViewportMetrics::New();
   metrics->size_in_pixels = mojo::Size::New();
   return metrics.Pass();
 }
 
 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;
 }
 
-ViewTreeHostImpl* ConnectionManager::GetViewTreeHostByView(
+ViewTreeHostImpl* ConnectionManager::GetWindowTreeHostByView(
     const ServerView* view) {
   return const_cast<ViewTreeHostImpl*>(
-      static_cast<const ConnectionManager*>(this)->GetViewTreeHostByView(view));
+      static_cast<const ConnectionManager*>(this)
+          ->GetWindowTreeHostByView(view));
 }
 
-const ViewTreeHostImpl* ConnectionManager::GetViewTreeHostByView(
+const ViewTreeHostImpl* ConnectionManager::GetWindowTreeHostByView(
     const ServerView* view) const {
   while (view && view->parent())
     view = view->parent();
   for (auto& pair : host_connection_map_) {
     if (view == pair.first->root_view())
       return pair.first;
   }
   return nullptr;
 }
 
@@ skipping 46 matching lines @@
     const ServerView* old_parent) {
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessViewHierarchyChanged(
         view, new_parent, old_parent, IsChangeSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessViewReorder(
     const ServerView* view,
     const ServerView* relative_view,
-    const mojo::OrderDirection direction) {
+    const mojom::OrderDirection direction) {
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessViewReorder(view, relative_view, direction,
                                                IsChangeSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessViewDeleted(const ViewId& view) {
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessViewDeleted(view,
                                                IsChangeSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessViewportMetricsChanged(
-    const mojo::ViewportMetrics& old_metrics,
-    const mojo::ViewportMetrics& new_metrics) {
+    const mojom::ViewportMetrics& old_metrics,
+    const mojom::ViewportMetrics& new_metrics) {
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessViewportMetricsChanged(
         old_metrics, new_metrics, IsChangeSource(pair.first));
   }
 }
 
 void ConnectionManager::PrepareForChange(ScopedChange* change) {
   // Should only ever have one change in flight.
   CHECK(!current_change_);
   current_change_ = change;
@@ skipping 13 matching lines @@
 SurfacesState* ConnectionManager::GetSurfacesState() {
   return surfaces_state_.get();
 }
 
 void ConnectionManager::OnScheduleViewPaint(const ServerView* view) {
   if (!in_destructor_)
     SchedulePaint(view, gfx::Rect(view->bounds().size()));
 }
 
 const ServerView* ConnectionManager::GetRootView(const ServerView* view) const {
-  const ViewTreeHostImpl* host = GetViewTreeHostByView(view);
+  const ViewTreeHostImpl* host = GetWindowTreeHostByView(view);
   return host ? host->root_view() : nullptr;
 }
 
 void ConnectionManager::OnViewDestroyed(ServerView* view) {
   if (!in_destructor_)
     ProcessViewDeleted(view->id());
 }
 
 void ConnectionManager::OnWillChangeViewHierarchy(ServerView* view,
                                                   ServerView* new_parent,
@@ skipping 39 matching lines @@
     const gfx::Rect& old_client_area,
     const gfx::Rect& new_client_area) {
   if (in_destructor_)
     return;
 
   ProcessClientAreaChanged(window, old_client_area, new_client_area);
 }
 
 void ConnectionManager::OnViewReordered(ServerView* view,
                                         ServerView* relative,
-                                        mojo::OrderDirection direction) {
+                                        mojom::OrderDirection direction) {
   if (!in_destructor_)
     SchedulePaint(view, gfx::Rect(view->bounds().size()));
 }
 
 void ConnectionManager::OnWillChangeViewVisibility(ServerView* view) {
   if (in_destructor_)
     return;
 
   // Need to repaint if the view was drawn (which means it's in the process of
   // hiding) or the view is transitioning to drawn.
@@ skipping 14 matching lines @@
     const std::vector<uint8_t>* new_data) {
   for (auto& pair : connection_map_) {
     pair.second->service()->ProcessViewPropertyChanged(
         view, name, new_data, IsChangeSource(pair.first));
   }
 }
 
 void ConnectionManager::OnViewTextInputStateChanged(
     ServerView* view,
     const ui::TextInputState& state) {
-  ViewTreeHostImpl* host = GetViewTreeHostByView(view);
+  ViewTreeHostImpl* host = GetWindowTreeHostByView(view);
   host->UpdateTextInputState(view, state);
 }
 
 }  // namespace mus