Replaced cc::Display::SetSurfaceId() with SetLocalFrameId()

cc/surfaces/display.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/display.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 15 matching lines @@
 
 #if defined(ENABLE_VULKAN)
 #include "cc/output/vulkan_renderer.h"
 #endif
 
 namespace cc {
 
 Display::Display(SharedBitmapManager* bitmap_manager,
                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
                  const RendererSettings& settings,
+                 const FrameSinkId& frame_sink_id,
                  std::unique_ptr<BeginFrameSource> begin_frame_source,
                  std::unique_ptr<OutputSurface> output_surface,
                  std::unique_ptr<DisplayScheduler> scheduler,
                  std::unique_ptr<TextureMailboxDeleter> texture_mailbox_deleter)
     : bitmap_manager_(bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       settings_(settings),
+      frame_sink_id_(frame_sink_id),
       begin_frame_source_(std::move(begin_frame_source)),
       output_surface_(std::move(output_surface)),
       scheduler_(std::move(scheduler)),
       texture_mailbox_deleter_(std::move(texture_mailbox_deleter)) {
   DCHECK(output_surface_);
   DCHECK_EQ(!scheduler_, !begin_frame_source_);
+  DCHECK(frame_sink_id_.is_valid());
   if (scheduler_)
     scheduler_->SetClient(this);
 }
 
 Display::~Display() {
   // Only do this if Initialize() happened.
   if (client_) {
     if (auto* context = output_surface_->context_provider())
       context->SetLostContextCallback(base::Closure());
     if (begin_frame_source_)
       surface_manager_->UnregisterBeginFrameSource(begin_frame_source_.get());
     surface_manager_->RemoveObserver(this);
   }
   if (aggregator_) {
     for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
       Surface* surface = surface_manager_->GetSurfaceForId(id_entry.first);
       if (surface)
         surface->RunDrawCallbacks();
     }
   }
 }
 
 void Display::Initialize(DisplayClient* client,
-                         SurfaceManager* surface_manager,
-                         const FrameSinkId& frame_sink_id) {
+                         SurfaceManager* surface_manager) {
   DCHECK(client);
   DCHECK(surface_manager);
   client_ = client;
   surface_manager_ = surface_manager;
-  frame_sink_id_ = frame_sink_id;
 
   surface_manager_->AddObserver(this);
 
   // This must be done in Initialize() so that the caller can delay this until
   // they are ready to receive a BeginFrameSource.
   if (begin_frame_source_) {
     surface_manager_->RegisterBeginFrameSource(begin_frame_source_.get(),
                                                frame_sink_id_);
   }
 
   output_surface_->BindToClient(this);
   InitializeRenderer();
 
   if (auto* context = output_surface_->context_provider()) {
     // This depends on assumptions that Display::Initialize will happen
     // on the same callstack as the ContextProvider being created/initialized
     // or else it could miss a callback before setting this.
     context->SetLostContextCallback(base::Bind(
         &Display::DidLoseContextProvider,
         // Unretained is safe since the callback is unset in this class'
         // destructor and is never posted.
         base::Unretained(this)));
   }
 }
 
-void Display::SetSurfaceId(const SurfaceId& id, float device_scale_factor) {
-  DCHECK(id.frame_sink_id() == frame_sink_id_);
-  if (current_surface_id_ == id && device_scale_factor_ == device_scale_factor)
+void Display::SetLocalFrameId(const LocalFrameId& id,
+                              float device_scale_factor) {
+  if (current_surface_id_.local_frame_id() == id &&
+      device_scale_factor_ == device_scale_factor) {
     return;
+  }
 
   TRACE_EVENT0("cc", "Display::SetSurfaceId");
-  current_surface_id_ = id;
+  current_surface_id_ = SurfaceId(frame_sink_id_, id);
   device_scale_factor_ = device_scale_factor;
 
   UpdateRootSurfaceResourcesLocked();
   if (scheduler_)
-    scheduler_->SetNewRootSurface(id);
+    scheduler_->SetNewRootSurface(current_surface_id_);
 }
 
 void Display::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "Display::SetVisible", "visible", visible);
   if (renderer_)
     renderer_->SetVisible(visible);
   if (scheduler_)
     scheduler_->SetVisible(visible);
   visible_ = visible;
 
@@ skipping 268 matching lines @@
 const SurfaceId& Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 void Display::ForceImmediateDrawAndSwapIfPossible() {
   if (scheduler_)
     scheduler_->ForceImmediateSwapIfPossible();
 }
 
 }  // namespace cc