components/mus/public/interfaces View => Window

components/mus/ws/view_tree_host_impl.cc

 // Copyright 2015 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/view_tree_host_impl.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/public/cpp/types.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/view_tree_host_delegate.h"
 #include "components/mus/ws/view_tree_impl.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 
 namespace mus {
 
 ViewTreeHostImpl::ViewTreeHostImpl(
-    mojo::ViewTreeHostClientPtr client,
+    mojom::WindowTreeHostClientPtr client,
     ConnectionManager* connection_manager,
     mojo::ApplicationImpl* app_impl,
     const scoped_refptr<GpuState>& gpu_state,
     const scoped_refptr<SurfacesState>& surfaces_state)
     : delegate_(nullptr),
       connection_manager_(connection_manager),
       client_(client.Pass()),
       event_dispatcher_(this),
-      display_manager_(DisplayManager::Create(app_impl,
-                                              gpu_state,
-                                              surfaces_state)),
+      display_manager_(
+          DisplayManager::Create(app_impl, gpu_state, surfaces_state)),
       focus_controller_(new FocusController(this)) {
   display_manager_->Init(this);
   if (client_) {
     client_.set_connection_error_handler(
         base::Bind(&ViewTreeHostImpl::OnClientClosed, base::Unretained(this)));
   }
 }
 
 ViewTreeHostImpl::~ViewTreeHostImpl() {}
 
 void ViewTreeHostImpl::Init(ViewTreeHostDelegate* delegate) {
   delegate_ = delegate;
   if (delegate_ && root_)
     delegate_->OnDisplayInitialized();
 }
 
-ViewTreeImpl* ViewTreeHostImpl::GetViewTree() {
-  return delegate_ ? delegate_->GetViewTree() : nullptr;
+ViewTreeImpl* ViewTreeHostImpl::GetWindowTree() {
+  return delegate_ ? delegate_->GetWindowTree() : nullptr;
 }
 
 bool ViewTreeHostImpl::IsViewAttachedToRoot(const ServerView* view) const {
   return root_->Contains(view) && view != root_.get();
 }
 
 bool ViewTreeHostImpl::SchedulePaintIfInViewport(const ServerView* view,
                                                  const gfx::Rect& bounds) {
   if (root_->Contains(view)) {
     display_manager_->SchedulePaint(view, bounds);
     return true;
   }
   return false;
 }
 
-const mojo::ViewportMetrics& ViewTreeHostImpl::GetViewportMetrics() const {
+const mojom::ViewportMetrics& ViewTreeHostImpl::GetViewportMetrics() const {
   return display_manager_->GetViewportMetrics();
 }
 
 void ViewTreeHostImpl::SetFocusedView(ServerView* new_focused_view) {
   ServerView* old_focused_view = focus_controller_->GetFocusedView();
   if (old_focused_view == new_focused_view)
     return;
   DCHECK(root_view()->Contains(new_focused_view));
   focus_controller_->SetFocusedView(new_focused_view);
   // TODO(beng): have the FocusController notify us via FocusControllerDelegate.
@@ skipping 74 matching lines @@
 void ViewTreeHostImpl::OnEvent(mojo::EventPtr event) {
   event_dispatcher_.OnEvent(event.Pass());
 }
 
 void ViewTreeHostImpl::OnDisplayClosed() {
   if (delegate_)
     delegate_->OnDisplayClosed();
 }
 
 void ViewTreeHostImpl::OnViewportMetricsChanged(
-    const mojo::ViewportMetrics& old_metrics,
-    const mojo::ViewportMetrics& new_metrics) {
+    const mojom::ViewportMetrics& old_metrics,
+    const mojom::ViewportMetrics& new_metrics) {
   if (!root_) {
     root_.reset(connection_manager_->CreateServerView(
         RootViewId(connection_manager_->GetAndAdvanceNextHostId())));
     root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
     root_->SetVisible(true);
     if (delegate_)
       delegate_->OnDisplayInitialized();
   } else {
     root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
   }
@@ skipping 49 matching lines @@
     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);
     }
   }
 
   // Ensure that we always notify the root connection of a focus change.
-  ViewTreeImpl* root_tree = GetViewTree();
+  ViewTreeImpl* root_tree = GetWindowTree();
   if (root_tree != owning_connection_old &&
       root_tree != embedded_connection_old &&
       root_tree != owning_connection_new &&
       root_tree != embedded_connection_new) {
     root_tree->ProcessFocusChanged(old_focused_view, new_focused_view);
   }
 
   UpdateTextInputState(new_focused_view, new_focused_view->text_input_state());
 }
 
 }  // namespace mus