Passing FrameSinkId to WindowCompositorFrameSink

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 1024 matching lines @@
 void RenderWidgetCompositor::RequestNewCompositorFrameSink() {
   // If the host is closing, then no more compositing is possible.  This
   // prevents shutdown races between handling the close message and
   // the CreateCompositorFrameSink task.
   if (delegate_->IsClosing())
     return;
 
   bool fallback = num_failed_recreate_attempts_ >=
                   COMPOSITOR_FRAME_SINK_RETRIES_BEFORE_FALLBACK;
   std::unique_ptr<cc::CompositorFrameSink> surface(
-      delegate_->CreateCompositorFrameSink(fallback));
+      delegate_->CreateCompositorFrameSink(frame_sink_id_, fallback));
 
   if (!surface) {
     DidFailToInitializeCompositorFrameSink();
     return;
   }
 
   layer_tree_host_->SetCompositorFrameSink(std::move(surface));
 }
 
 void RenderWidgetCompositor::DidInitializeCompositorFrameSink() {
@@ skipping 54 matching lines @@
     const cc::proto::CompositorMessage& proto) {
   int signed_size = proto.ByteSize();
   size_t unsigned_size = base::checked_cast<size_t>(signed_size);
   std::vector<uint8_t> serialized(unsigned_size);
   proto.SerializeToArray(serialized.data(), signed_size);
   delegate_->ForwardCompositorProto(serialized);
 }
 
 void RenderWidgetCompositor::SetFrameSinkId(
     const cc::FrameSinkId& frame_sink_id) {
+  frame_sink_id_ = frame_sink_id;
   layer_tree_host_->SetFrameSinkId(frame_sink_id);
 }
 
 void RenderWidgetCompositor::OnHandleCompositorProto(
     const std::vector<uint8_t>& proto) {
   DCHECK(remote_proto_channel_receiver_);
 
   std::unique_ptr<cc::proto::CompositorMessage> deserialized(
       new cc::proto::CompositorMessage);
   int signed_size = base::checked_cast<int>(proto.size());
   if (!deserialized->ParseFromArray(proto.data(), signed_size)) {
     LOG(ERROR) << "Unable to parse compositor proto.";
     return;
   }
 
   remote_proto_channel_receiver_->OnProtoReceived(std::move(deserialized));
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->GetLayerTree()->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 void RenderWidgetCompositor::SetDeviceColorSpace(
     const gfx::ColorSpace& color_space) {
   layer_tree_host_->GetLayerTree()->SetDeviceColorSpace(color_space);
 }
 
 }  // namespace content