Move display_ From CompositorFrameSinkSupport To GpuDisplayCompositorFrameSink

cc/surfaces/direct_compositor_frame_sink.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 "cc/surfaces/direct_compositor_frame_sink.h"
 
 #include "base/bind.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_sink_client.h"
 #include "cc/surfaces/display.h"
@@ skipping 49 matching lines @@
 
   if (!CompositorFrameSink::BindToClient(client))
     return false;
 
   // We want the Display's output surface to hear about lost context, and since
   // this shares a context with it, we should not be listening for lost context
   // callbacks on the context here.
   if (auto* cp = context_provider())
     cp->SetLostContextCallback(base::Closure());
 
+  const bool submits_to_display_compositor = true;

[Fady Samuel, 2017/02/08 21:37:46]

constexpr

[Alex Z., 2017/02/08 21:41:43]

Done.

   support_ = base::MakeUnique<CompositorFrameSinkSupport>(
-      this, surface_manager_, frame_sink_id_, display_, false,
-      capabilities_.delegated_sync_points_required);
+      this, surface_manager_, frame_sink_id_, false,
+      capabilities_.delegated_sync_points_required,
+      submits_to_display_compositor);
 
   begin_frame_source_ = base::MakeUnique<ExternalBeginFrameSource>(this);
   client_->SetBeginFrameSource(begin_frame_source_.get());
+
   // Avoid initializing GL context here, as this should be sharing the
   // Display's context.
+  display_->Initialize(this, surface_manager_);
 
   return true;
 }
 
 void DirectCompositorFrameSink::DetachFromClient() {
   client_->SetBeginFrameSource(nullptr);
   begin_frame_source_.reset();
   support_.reset();
   CompositorFrameSink::DetachFromClient();
 }
 
 void DirectCompositorFrameSink::SubmitCompositorFrame(CompositorFrame frame) {
   gfx::Size frame_size = frame.render_pass_list.back()->output_rect.size();
   if (frame_size.IsEmpty() || frame_size != last_swap_frame_size_) {
     delegated_local_surface_id_ = surface_id_allocator_.GenerateId();
     last_swap_frame_size_ = frame_size;
   }
+  display_->SetLocalSurfaceId(delegated_local_surface_id_,
+                              frame.metadata.device_scale_factor);
   support_->SubmitCompositorFrame(delegated_local_surface_id_,
                                   std::move(frame));
 }
 
 void DirectCompositorFrameSink::ForceReclaimResources() {
   support_->ForceReclaimResources();
 }
 
 void DirectCompositorFrameSink::DisplayOutputSurfaceLost() {
   is_lost_ = true;
@@ skipping 31 matching lines @@
 
 void DirectCompositorFrameSink::DidDrawCallback() {
   client_->DidReceiveCompositorFrameAck();
 }
 
 void DirectCompositorFrameSink::OnNeedsBeginFrames(bool needs_begin_frame) {
   support_->SetNeedsBeginFrame(needs_begin_frame);
 }
 
 }  // namespace cc