Nukes NativeViewportClient::OnCreated

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/display_manager.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
@@ skipping 56 matching lines @@
 }
 
 }  // namespace
 
 DisplayManager::DisplayManager(
     ApplicationConnection* app_connection,
     ConnectionManager* connection_manager,
     const Callback<void()>& native_viewport_closed_callback)
     : connection_manager_(connection_manager),
       in_setup_(false),
-      bounds_(800, 600),
+      size_(800, 600),
       draw_timer_(false, false),
       weak_factory_(this) {
   app_connection->ConnectToService("mojo:mojo_native_viewport_service",
                                    &native_viewport_);
   native_viewport_.set_client(this);
-  native_viewport_->Create(Size::From(bounds_));
+  native_viewport_->Create(
+      Size::From(size_),
+      base::Bind(&DisplayManager::OnCreatedNativeViewport,
+                 weak_factory_.GetWeakPtr()));
   native_viewport_->Show();
   app_connection->ConnectToService("mojo:mojo_surfaces_service",
                                    &surfaces_service_);
   surfaces_service_->CreateSurfaceConnection(base::Bind(
       &DisplayManager::OnSurfaceConnectionCreated, weak_factory_.GetWeakPtr()));
 }
 
 DisplayManager::~DisplayManager() {
 }
 
 void DisplayManager::SchedulePaint(const ServerView* view,
                                    const gfx::Rect& bounds) {
   if (!view->visible())
     return;
   gfx::Rect root_relative_rect = ConvertRectToRoot(view, bounds);
   if (root_relative_rect.IsEmpty())
     return;
   dirty_rect_.Union(root_relative_rect);
   if (!draw_timer_.IsRunning()) {
     draw_timer_.Start(
         FROM_HERE,
         base::TimeDelta(),
         base::Bind(&DisplayManager::Draw, base::Unretained(this)));
   }
 }
 
+void DisplayManager::OnCreatedNativeViewport(uint64_t native_viewport_id) {
+}
+
 void DisplayManager::OnSurfaceConnectionCreated(SurfacePtr surface,
                                                 uint32_t id_namespace) {
   surface_ = surface.Pass();
   surface_.set_client(this);
   surface_id_allocator_.reset(new cc::SurfaceIdAllocator(id_namespace));
   Draw();
 }
 
 void DisplayManager::Draw() {
   if (!surface_)
     return;
   if (surface_id_.is_null()) {
     surface_id_ = surface_id_allocator_->GenerateId();
-    surface_->CreateSurface(SurfaceId::From(surface_id_), Size::From(bounds_));
+    surface_->CreateSurface(SurfaceId::From(surface_id_), Size::From(size_));
   }
 
-  PassPtr pass = CreateDefaultPass(1, gfx::Rect(bounds_));
+  PassPtr pass = CreateDefaultPass(1, gfx::Rect(size_));
   pass->damage_rect = Rect::From(dirty_rect_);
 
   DrawViewTree(pass.get(), connection_manager_->root(), gfx::Vector2d());
 
   FramePtr frame = Frame::New();
   frame->passes.push_back(pass.Pass());
   frame->resources.resize(0u);
   surface_->SubmitFrame(SurfaceId::From(surface_id_), frame.Pass());
 
   native_viewport_->SubmittedFrame(SurfaceId::From(surface_id_));
 
   dirty_rect_ = gfx::Rect();
 }
 
-void DisplayManager::OnCreated(uint64_t native_viewport_id) {
-}
-
 void DisplayManager::OnDestroyed() {
   native_viewport_closed_callback_.Run();
 }
 
-void DisplayManager::OnBoundsChanged(SizePtr bounds) {
-  bounds_ = bounds.To<gfx::Size>();
-  connection_manager_->root()->SetBounds(gfx::Rect(bounds_));
+void DisplayManager::OnSizeChanged(SizePtr size) {
+  size_ = size.To<gfx::Size>();
+  connection_manager_->root()->SetBounds(gfx::Rect(size_));
   if (surface_id_.is_null())
     return;
   surface_->DestroySurface(SurfaceId::From(surface_id_));
   surface_id_ = cc::SurfaceId();
-  SchedulePaint(connection_manager_->root(), gfx::Rect(bounds_));
+  SchedulePaint(connection_manager_->root(), gfx::Rect(size_));
 }
 
 void DisplayManager::OnEvent(EventPtr event,
                              const mojo::Callback<void()>& callback) {
   connection_manager_->DispatchViewInputEventToWindowManager(event.Pass());
   callback.Run();
 }
 
 void DisplayManager::ReturnResources(Array<ReturnedResourcePtr> resources) {
   DCHECK_EQ(0u, resources.size());
 }
 
 }  // namespace service
 }  // namespace mojo