services/ui: Split GpuServiceInternal into gpu vs. ws pieces.

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 "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/gpu/gpu_service_internal.h"
+#include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/ui/surfaces/display_compositor.h"
 #include "services/ui/ws/frame_generator_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_surface.h"
 #include "services/ui/ws/server_window_surface_manager.h"
 
 namespace ui {
 
 namespace ws {
 
 FrameGenerator::FrameGenerator(FrameGeneratorDelegate* delegate,
                                scoped_refptr<SurfacesState> surfaces_state)
     : delegate_(delegate),
       surfaces_state_(surfaces_state),
       draw_timer_(false, false),
       weak_factory_(this) {
   DCHECK(delegate_);
 }
 
 FrameGenerator::~FrameGenerator() {
   // Invalidate WeakPtrs now to avoid callbacks back into the
   // FrameGenerator during destruction of |display_compositor_|.
   weak_factory_.InvalidateWeakPtrs();
   display_compositor_.reset();
 }
 
+void FrameGenerator::OnGpuChannelEstablished(
+    scoped_refptr<gpu::GpuChannelHost> channel) {
+  if (widget_ != gfx::kNullAcceleratedWidget) {
+    display_compositor_.reset(
+        new DisplayCompositor(base::ThreadTaskRunnerHandle::Get(), widget_,
+                              std::move(channel), surfaces_state_));
+  } else {
+    gpu_channel_ = std::move(channel);
+  }
+}
+
 void FrameGenerator::RequestRedraw(const gfx::Rect& redraw_region) {
   dirty_rect_.Union(redraw_region);
   WantToDraw();
 }
 
 void FrameGenerator::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget) {
-  if (widget != gfx::kNullAcceleratedWidget) {
-    display_compositor_.reset(new DisplayCompositor(
-        base::ThreadTaskRunnerHandle::Get(), widget,
-        GpuServiceInternal::GetInstance()->gpu_channel_local(),
-        surfaces_state_));
+  widget_ = widget;
+  if (gpu_channel_) {
+    display_compositor_.reset(
+        new DisplayCompositor(base::ThreadTaskRunnerHandle::Get(), widget_,
+                              std::move(gpu_channel_), surfaces_state_));
   }
 }
 
 void FrameGenerator::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> output_request) {
   if (display_compositor_)
     display_compositor_->RequestCopyOfOutput(std::move(output_request));
 }
 
 void FrameGenerator::WantToDraw() {
@@ skipping 16 matching lines @@
   // TODO(fsamuel): We should add a trace for generating a top level frame.
   cc::CompositorFrame frame(GenerateCompositorFrame(output_rect));
   if (frame.metadata.may_contain_video != may_contain_video_) {
     may_contain_video_ = frame.metadata.may_contain_video;
     // TODO(sad): Schedule notifying observers.
     if (may_contain_video_) {
       // TODO(sad): Start a timer to reset the bit if no new frame with video
       // is submitted 'soon'.
     }
   }
-  frame_pending_ = true;
   if (display_compositor_) {
+    frame_pending_ = true;
     display_compositor_->SubmitCompositorFrame(
         std::move(frame),
         base::Bind(&FrameGenerator::DidDraw, weak_factory_.GetWeakPtr()));
   }
   dirty_rect_ = gfx::Rect();
 }
 
 void FrameGenerator::DidDraw() {
   frame_pending_ = false;
   delegate_->OnCompositorFrameDrawn();
@@ skipping 115 matching lines @@
                  gfx::Rect() /* opaque_rect */,
                  bounds_at_origin /* visible_rect */, true /* needs_blending*/,
                  underlay_surface->id());
     DCHECK(!underlay_surface->may_contain_video());
   }
 }
 
 }  // namespace ws
 
 }  // namespace ui