Revert of FrameGenerator should not be created until an AcceleratedWidget is available

services/ui/ws/frame_generator.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/frame_generator.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/adapters.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "services/ui/ws/frame_generator_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 #include "services/ui/ws/server_window_delegate.h"
 
 namespace ui {
 
 namespace ws {
 
 FrameGenerator::FrameGenerator(FrameGeneratorDelegate* delegate,
-                               ServerWindow* root_window,
-                               gfx::AcceleratedWidget widget)
-    : delegate_(delegate), root_window_(root_window), binding_(this) {
+                               ServerWindow* root_window)
+    : delegate_(delegate),
+      root_window_(root_window),
+      binding_(this) {
   DCHECK(delegate_);
+}
+
+void FrameGenerator::SetDeviceScaleFactor(float device_scale_factor) {
+  if (device_scale_factor_ == device_scale_factor)
+    return;
+  device_scale_factor_ = device_scale_factor;
+  if (compositor_frame_sink_)
+    compositor_frame_sink_->SetNeedsBeginFrame(true);
+}
+
+FrameGenerator::~FrameGenerator() {
+  compositor_frame_sink_.reset();
+}
+
+void FrameGenerator::OnAcceleratedWidgetAvailable(
+    gfx::AcceleratedWidget widget) {
   DCHECK_NE(gfx::kNullAcceleratedWidget, widget);
   cc::mojom::MojoCompositorFrameSinkAssociatedRequest sink_request =
       mojo::MakeRequest(&compositor_frame_sink_);
   cc::mojom::DisplayPrivateAssociatedRequest display_request =
       mojo::MakeRequest(&display_private_);
   root_window_->CreateDisplayCompositorFrameSink(
       widget, std::move(sink_request), binding_.CreateInterfacePtrAndBind(),
       std::move(display_request));
 }
 
-FrameGenerator::~FrameGenerator() = default;
-
-void FrameGenerator::SetDeviceScaleFactor(float device_scale_factor) {
-  if (device_scale_factor_ == device_scale_factor)
-    return;
-  device_scale_factor_ = device_scale_factor;
-  compositor_frame_sink_->SetNeedsBeginFrame(true);
-}
-
 void FrameGenerator::OnSurfaceCreated(const cc::SurfaceInfo& surface_info) {
   DCHECK(surface_info.id().is_valid());
 
   // Only handle embedded surfaces changing here. The display root surface
   // changing is handled immediately after the CompositorFrame is submitted.
   if (surface_info != window_manager_surface_info_) {
     window_manager_surface_info_ = surface_info;
     compositor_frame_sink_->SetNeedsBeginFrame(true);
   }
 }
 
 void FrameGenerator::OnWindowDamaged() {
   if (window_manager_surface_info_.id().is_valid())
     compositor_frame_sink_->SetNeedsBeginFrame(true);
 }
 
 void FrameGenerator::DidReceiveCompositorFrameAck() {}
 
 void FrameGenerator::OnBeginFrame(const cc::BeginFrameArgs& begin_frame_arags) {
   if (!root_window_->visible())
     return;
 
   // TODO(fsamuel): We should add a trace for generating a top level frame.
   cc::CompositorFrame frame(GenerateCompositorFrame(root_window_->bounds()));
 
-  gfx::Size frame_size = last_submitted_frame_size_;
-  if (!frame.render_pass_list.empty())
-    frame_size = frame.render_pass_list.back()->output_rect.size();
+  if (compositor_frame_sink_) {
+    gfx::Size frame_size = last_submitted_frame_size_;
+    if (!frame.render_pass_list.empty())
+      frame_size = frame.render_pass_list[0]->output_rect.size();
 
-  if (!local_surface_id_.is_valid() ||
-      frame_size != last_submitted_frame_size_) {
-    local_surface_id_ = id_allocator_.GenerateId();
-    display_private_->ResizeDisplay(frame_size);
+    if (!local_surface_id_.is_valid() ||
+        frame_size != last_submitted_frame_size_) {
+      local_surface_id_ = id_allocator_.GenerateId();
+      display_private_->ResizeDisplay(frame_size);
+    }
+
+    display_private_->SetLocalSurfaceId(local_surface_id_,
+                                        device_scale_factor_);
+    compositor_frame_sink_->SubmitCompositorFrame(local_surface_id_,
+                                                  std::move(frame));
+    compositor_frame_sink_->SetNeedsBeginFrame(false);
+    last_submitted_frame_size_ = frame_size;
   }
-
-  display_private_->SetLocalSurfaceId(local_surface_id_, device_scale_factor_);
-  compositor_frame_sink_->SubmitCompositorFrame(local_surface_id_,
-                                                std::move(frame));
-  compositor_frame_sink_->SetNeedsBeginFrame(false);
-  last_submitted_frame_size_ = frame_size;
 }
 
 void FrameGenerator::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
   // Nothing to do here because FrameGenerator CompositorFrames don't reference
   // any resources.
   DCHECK(resources.empty());
 }
 
 void FrameGenerator::WillDrawSurface(const cc::LocalSurfaceId& local_surface_id,
@@ skipping 68 matching lines @@
   auto* quad = pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
   quad->SetAll(sqs, bounds_at_origin /* rect */, gfx::Rect() /* opaque_rect */,
                bounds_at_origin /* visible_rect */, true /* needs_blending*/,
                window_manager_surface_info_.id(),
                cc::SurfaceDrawQuadType::PRIMARY, nullptr);
 }
 
 }  // namespace ws
 
 }  // namespace ui