Rename RootViewManager to DisplayManager

mojo/services/view_manager/display_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 "mojo/services/view_manager/root_view_manager.h"
+#include "mojo/services/view_manager/display_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/scoped_observer.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/services/public/interfaces/gpu/gpu.mojom.h"
+#include "mojo/services/view_manager/display_manager_delegate.h"
 #include "mojo/services/view_manager/root_node_manager.h"
-#include "mojo/services/view_manager/root_view_manager_delegate.h"
 #include "mojo/services/view_manager/screen_impl.h"
 #include "mojo/services/view_manager/window_tree_host_impl.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
@@ skipping 24 matching lines @@
                        origin.x(), origin.y());
   std::vector<const Node*> children(node->GetChildren());
   for (size_t i = 0; i < children.size(); ++i) {
     PaintNodeTree(canvas, children[i],
                   origin + children[i]->bounds().OffsetFromOrigin());
   }
 }
 
 }  // namespace
 
-class RootViewManager::RootWindowDelegateImpl : public aura::WindowDelegate {
+class DisplayManager::RootWindowDelegateImpl : public aura::WindowDelegate {
  public:
   explicit RootWindowDelegateImpl(const Node* root_node)
       : root_node_(root_node) {}
   virtual ~RootWindowDelegateImpl() {}
 
   // aura::WindowDelegate:
   virtual gfx::Size GetMinimumSize() const OVERRIDE {
     return gfx::Size();
   }
   virtual gfx::Size GetMaximumSize() const OVERRIDE {
@@ skipping 82 matching lines @@
   }
 
  private:
   aura::Window* window_;
 
   scoped_ptr<aura::client::DefaultCaptureClient> capture_client_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientImpl);
 };
 
-RootViewManager::RootViewManager(
+DisplayManager::DisplayManager(
     ApplicationConnection* app_connection,
     RootNodeManager* root_node,
-    RootViewManagerDelegate* delegate,
+    DisplayManagerDelegate* delegate,
     const Callback<void()>& native_viewport_closed_callback)
     : delegate_(delegate),
       root_node_manager_(root_node),
       in_setup_(false),
       root_window_(NULL) {
   screen_.reset(ScreenImpl::Create());
   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
   NativeViewportPtr viewport;
   app_connection->ConnectToService(
       "mojo:mojo_native_viewport_service", &viewport);
   GpuPtr gpu_service;
   // TODO(jamesr): Should be mojo:mojo_gpu_service
   app_connection->ConnectToService("mojo:mojo_native_viewport_service",
                                    &gpu_service);
   window_tree_host_.reset(new WindowTreeHostImpl(
       viewport.Pass(),
       gpu_service.Pass(),
       gfx::Rect(800, 600),
-      base::Bind(&RootViewManager::OnCompositorCreated, base::Unretained(this)),
+      base::Bind(&DisplayManager::OnCompositorCreated, base::Unretained(this)),
       native_viewport_closed_callback,
       base::Bind(&RootNodeManager::DispatchNodeInputEventToWindowManager,
                  base::Unretained(root_node_manager_))));
 }
 
-RootViewManager::~RootViewManager() {
+DisplayManager::~DisplayManager() {
   window_tree_client_.reset();
   window_tree_host_.reset();
   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, NULL);
 }
 
-void RootViewManager::SchedulePaint(const Node* node, const gfx::Rect& bounds) {
+void DisplayManager::SchedulePaint(const Node* node, const gfx::Rect& bounds) {
   if (root_window_)
     root_window_->SchedulePaintInRect(ConvertRectToRoot(node, bounds));
 }
 
-void RootViewManager::OnCompositorCreated() {
+void DisplayManager::OnCompositorCreated() {
   base::AutoReset<bool> resetter(&in_setup_, true);
   window_tree_host_->InitHost();
 
   window_delegate_.reset(
       new RootWindowDelegateImpl(root_node_manager_->root()));
   root_window_ = new aura::Window(window_delegate_.get());
   root_window_->Init(aura::WINDOW_LAYER_TEXTURED);
   root_window_->Show();
   root_window_->SetBounds(
       gfx::Rect(window_tree_host_->window()->bounds().size()));
   window_tree_host_->window()->AddChild(root_window_);
 
   root_node_manager_->root()->SetBounds(
       gfx::Rect(window_tree_host_->window()->bounds().size()));
 
   window_tree_client_.reset(
       new WindowTreeClientImpl(window_tree_host_->window()));
 
   focus_client_.reset(new FocusClientImpl);
   aura::client::SetFocusClient(window_tree_host_->window(),
                                focus_client_.get());
 
   window_tree_host_->Show();
 
-  delegate_->OnRootViewManagerWindowTreeHostCreated();
+  delegate_->OnDisplayManagerWindowTreeHostCreated();
 }
 
 }  // namespace service
 }  // namespace mojo