FrameGenerator should not be created until an AcceleratedWidget is available

services/ui/ws/platform_display_default.cc

 // Copyright 2016 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 "services/ui/ws/platform_display_default.h"
 
 #include "base/memory/ptr_util.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/ui/display/screen_manager.h"
 #include "services/ui/ws/platform_display_init_params.h"
@@ skipping 17 matching lines @@
 
 namespace ui {
 namespace ws {
 
 PlatformDisplayDefault::PlatformDisplayDefault(
     const PlatformDisplayInitParams& init_params)
     : display_id_(init_params.display_id),
 #if !defined(OS_ANDROID)
       image_cursors_(new ImageCursors),
 #endif
-      frame_generator_(new FrameGenerator(this, init_params.root_window)),
       metrics_(init_params.metrics),
-      widget_(gfx::kNullAcceleratedWidget) {
-  frame_generator_->SetDeviceScaleFactor(
-      init_params.metrics.device_scale_factor);
+      widget_(gfx::kNullAcceleratedWidget),
+      root_window_(init_params.root_window),
+      init_device_scale_factor_(init_params.metrics.device_scale_factor) {
 }
 
 PlatformDisplayDefault::~PlatformDisplayDefault() {
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
 
   frame_generator_.reset();
   // Destroy the PlatformWindow early on as it may call us back during
   // destruction and we want to be in a known state. But destroy the surface
   // first because it can still be using the platform window.
@@ skipping 88 matching lines @@
   if (metrics_ == metrics)
     return false;
 
   gfx::Rect bounds = platform_window_->GetBounds();
   if (bounds.size() != metrics.pixel_size) {
     bounds.set_size(metrics.pixel_size);
     platform_window_->SetBounds(bounds);
   }
 
   metrics_ = metrics;
-  frame_generator_->SetDeviceScaleFactor(metrics_.device_scale_factor);
+  if (frame_generator_)
+    frame_generator_->SetDeviceScaleFactor(metrics_.device_scale_factor);
   return true;
 }
 
 const display::ViewportMetrics& PlatformDisplayDefault::GetViewportMetrics()
     const {
   return metrics_;
 }
 
 gfx::AcceleratedWidget PlatformDisplayDefault::GetAcceleratedWidget() const {
   return widget_;
 }
 
 void PlatformDisplayDefault::UpdateEventRootLocation(ui::LocatedEvent* event) {
   gfx::Point location = event->location();
   location.Offset(metrics_.bounds.x(), metrics_.bounds.y());
   event->set_root_location(location);
 }
 
 void PlatformDisplayDefault::OnBoundsChanged(const gfx::Rect& new_bounds) {
   // We only care if the window size has changed.
   if (new_bounds.size() == metrics_.pixel_size)
     return;
 
   // TODO(kylechar): Maybe do something here. For CrOS we don't need to support
   // PlatformWindow initiated resizes. For other platforms we need to do
   // something but that isn't fully flushed out.
 }
 
 void PlatformDisplayDefault::OnDamageRect(const gfx::Rect& damaged_region) {
-  frame_generator_->OnWindowDamaged();
+  if (frame_generator_)
+    frame_generator_->OnWindowDamaged();
 }
 
 void PlatformDisplayDefault::DispatchEvent(ui::Event* event) {
   if (event->IsLocatedEvent())
     UpdateEventRootLocation(event->AsLocatedEvent());
 
   if (event->IsScrollEvent()) {
     // TODO(moshayedi): crbug.com/602859. Dispatch scroll events as
     // they are once we have proper support for scroll events.
     delegate_->OnEvent(
@@ skipping 48 matching lines @@
 
 void PlatformDisplayDefault::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_scale_factor) {
   // This will get called after Init() is called, either synchronously as part
   // of the Init() callstack or async after Init() has returned, depending on
   // the platform.
   DCHECK_EQ(gfx::kNullAcceleratedWidget, widget_);
   widget_ = widget;
   delegate_->OnAcceleratedWidgetAvailable();
-  frame_generator_->OnAcceleratedWidgetAvailable(widget);
+  frame_generator_.reset(new FrameGenerator(this, root_window_, widget_));
+  frame_generator_->SetDeviceScaleFactor(init_device_scale_factor_);
 }
 
 void PlatformDisplayDefault::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void PlatformDisplayDefault::OnActivationChanged(bool active) {}
 
 bool PlatformDisplayDefault::IsInHighContrastMode() {
   return delegate_ ? delegate_->IsInHighContrastMode() : false;
 }
 
 }  // namespace ws
 }  // namespace ui