Replace usage of SurfaceId's client_id with FrameSinkId

cc/surfaces/surface.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/surface.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 71 matching lines @@
   bool referenced_surfaces_changed =
       (referenced_surfaces_ != new_referenced_surfaces);
   referenced_surfaces_ = new_referenced_surfaces;
   std::vector<uint32_t> satisfies_sequences =
       std::move(current_frame_.metadata.satisfies_sequences);
 
   if (referenced_surfaces_changed || !satisfies_sequences.empty()) {
     // Notify the manager that sequences were satisfied either if some new
     // sequences were satisfied, or if the set of referenced surfaces changed
     // to force a GC to happen.
-    factory_->manager()->DidSatisfySequences(surface_id_.client_id(),
+    factory_->manager()->DidSatisfySequences(surface_id_.frame_sink_id(),
                                              &satisfies_sequences);
   }
 }
 
 void Surface::RequestCopyOfOutput(
     std::unique_ptr<CopyOutputRequest> copy_request) {
   if (current_frame_.delegated_frame_data &&
       !current_frame_.delegated_frame_data->render_pass_list.empty()) {
     std::vector<std::unique_ptr<CopyOutputRequest>>& copy_requests =
         current_frame_.delegated_frame_data->render_pass_list.back()
@@ skipping 55 matching lines @@
     callback.Run();
   }
 }
 
 void Surface::AddDestructionDependency(SurfaceSequence sequence) {
   destruction_dependencies_.push_back(sequence);
 }
 
 void Surface::SatisfyDestructionDependencies(
     std::unordered_set<SurfaceSequence, SurfaceSequenceHash>* sequences,
-    std::unordered_set<uint32_t>* valid_client_ids) {
+    std::unordered_set<FrameSinkId, FrameSinkIdHash>* valid_frame_sink_ids) {
   destruction_dependencies_.erase(
       std::remove_if(destruction_dependencies_.begin(),
                      destruction_dependencies_.end(),
-                     [sequences, valid_client_ids](SurfaceSequence seq) {
+                     [sequences, valid_frame_sink_ids](SurfaceSequence seq) {
                        return (!!sequences->erase(seq) ||
-                               !valid_client_ids->count(seq.client_id));
+                               !valid_frame_sink_ids->count(seq.frame_sink_id));
                      }),
       destruction_dependencies_.end());
 }
 
 void Surface::UnrefFrameResources(DelegatedFrameData* frame_data) {
   ReturnedResourceArray resources;
   TransferableResource::ReturnResources(frame_data->resource_list, &resources);
   // No point in returning same sync token to sender.
   for (auto& resource : resources)
     resource.sync_token.Clear();
   factory_->UnrefResources(resources);
 }
 
 void Surface::ClearCopyRequests() {
   if (current_frame_.delegated_frame_data) {
     for (const auto& render_pass :
          current_frame_.delegated_frame_data->render_pass_list) {
       for (const auto& copy_request : render_pass->copy_requests)
         copy_request->SendEmptyResult();
     }
   }
 }
 
 }  // namespace cc