Introduce cc::LocalFrameId and use in SurfaceFactory

content/browser/frame_host/render_widget_host_view_child_frame.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 "content/browser/frame_host/render_widget_host_view_child_frame.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 34 matching lines @@
       frame_sink_id_(
           base::checked_cast<uint32_t>(widget_host->GetProcess()->GetID()),
           base::checked_cast<uint32_t>(widget_host->GetRoutingID())),
       next_surface_sequence_(1u),
       last_compositor_frame_sink_id_(0),
       current_surface_scale_factor_(1.f),
       ack_pending_count_(0),
       frame_connector_(nullptr),
       begin_frame_source_(nullptr),
       weak_factory_(this) {
-  id_allocator_.reset(new cc::SurfaceIdAllocator(frame_sink_id_));
+  id_allocator_.reset(new cc::SurfaceIdAllocator());
   GetSurfaceManager()->RegisterFrameSinkId(frame_sink_id_);
   RegisterFrameSinkId();
 
   host_->SetView(this);
   GetTextInputManager();
 }
 
 RenderWidgetHostViewChildFrame::~RenderWidgetHostViewChildFrame() {
-  if (!surface_id_.is_null())
-    surface_factory_->Destroy(surface_id_);
+  if (!local_frame_id_.is_null())
+    surface_factory_->Destroy(local_frame_id_);
 
   if (GetSurfaceManager())
     GetSurfaceManager()->InvalidateFrameSinkId(frame_sink_id_);
 }
 
 void RenderWidgetHostViewChildFrame::SetCrossProcessFrameConnector(
     CrossProcessFrameConnector* frame_connector) {
   if (frame_connector_ == frame_connector)
     return;
 
@@ skipping 54 matching lines @@
 void RenderWidgetHostViewChildFrame::Focus() {
 }
 
 bool RenderWidgetHostViewChildFrame::HasFocus() const {
   if (frame_connector_)
     return frame_connector_->HasFocus();
   return false;
 }
 
 bool RenderWidgetHostViewChildFrame::IsSurfaceAvailableForCopy() const {
-  return surface_factory_ && !surface_id_.is_null();
+  return surface_factory_ && !local_frame_id_.is_null();
 }
 
 void RenderWidgetHostViewChildFrame::Show() {
   if (!host_->is_hidden())
     return;
   host_->WasShown(ui::LatencyInfo());
 }
 
 void RenderWidgetHostViewChildFrame::Hide() {
   if (host_->is_hidden())
@@ skipping 218 matching lines @@
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
 
   gfx::Size frame_size = root_pass->output_rect.size();
   float scale_factor = frame.metadata.device_scale_factor;
 
   // Check whether we need to recreate the cc::Surface, which means the child
   // frame renderer has changed its output surface, or size, or scale factor.
   if (compositor_frame_sink_id != last_compositor_frame_sink_id_ &&
       surface_factory_) {
-    surface_factory_->Destroy(surface_id_);
+    surface_factory_->Destroy(local_frame_id_);
     surface_factory_.reset();
   }
   if (compositor_frame_sink_id != last_compositor_frame_sink_id_ ||
       frame_size != current_surface_size_ ||
       scale_factor != current_surface_scale_factor_) {
     ClearCompositorSurfaceIfNecessary();
     last_compositor_frame_sink_id_ = compositor_frame_sink_id;
     current_surface_size_ = frame_size;
     current_surface_scale_factor_ = scale_factor;
   }
 
   if (!surface_factory_) {
     cc::SurfaceManager* manager = GetSurfaceManager();
     surface_factory_ =
         base::MakeUnique<cc::SurfaceFactory>(frame_sink_id_, manager, this);
   }
 
-  if (surface_id_.is_null()) {
-    surface_id_ = id_allocator_->GenerateId();
-    surface_factory_->Create(surface_id_);
+  if (local_frame_id_.is_null()) {
+    local_frame_id_ = id_allocator_->GenerateId();
+    surface_factory_->Create(local_frame_id_);
 
     cc::SurfaceSequence sequence =
         cc::SurfaceSequence(frame_sink_id_, next_surface_sequence_++);
     // The renderer process will satisfy this dependency when it creates a
     // SurfaceLayer.
     cc::SurfaceManager* manager = GetSurfaceManager();
-    manager->GetSurfaceForId(surface_id_)->AddDestructionDependency(sequence);
-    frame_connector_->SetChildFrameSurface(surface_id_, frame_size,
-                                           scale_factor, sequence);
+    manager->GetSurfaceForId(cc::SurfaceId(frame_sink_id_, local_frame_id_))
+        ->AddDestructionDependency(sequence);
+    frame_connector_->SetChildFrameSurface(
+        cc::SurfaceId(frame_sink_id_, local_frame_id_), frame_size,
+        scale_factor, sequence);
   }
 
   cc::SurfaceFactory::DrawCallback ack_callback =
       base::Bind(&RenderWidgetHostViewChildFrame::SurfaceDrawn, AsWeakPtr(),
                  compositor_frame_sink_id);
   ack_pending_count_++;
   // If this value grows very large, something is going wrong.
   DCHECK_LT(ack_pending_count_, 1000U);
-  surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
+  surface_factory_->SubmitCompositorFrame(local_frame_id_, std::move(frame),
                                           ack_callback);
 
   ProcessFrameSwappedCallbacks();
 }
 
 void RenderWidgetHostViewChildFrame::ProcessFrameSwappedCallbacks() {
   // We only use callbacks once, therefore we make a new list for registration
   // before we start, and discard the old list entries when we are done.
   FrameSwappedCallbackList process_callbacks;
   process_callbacks.swap(frame_swapped_callbacks_);
@@ skipping 79 matching lines @@
     const blink::WebGestureEvent& event,
     const ui::LatencyInfo& latency) {
   host_->ForwardGestureEventWithLatencyInfo(event, latency);
 }
 
 gfx::Point RenderWidgetHostViewChildFrame::TransformPointToRootCoordSpace(
     const gfx::Point& point) {
   if (!frame_connector_)
     return point;
 
-  return frame_connector_->TransformPointToRootCoordSpace(point, surface_id_);
+  return frame_connector_->TransformPointToRootCoordSpace(
+      point, cc::SurfaceId(frame_sink_id_, local_frame_id_));
 }
 
 gfx::Point RenderWidgetHostViewChildFrame::TransformPointToLocalCoordSpace(
     const gfx::Point& point,
     const cc::SurfaceId& original_surface) {
-  if (!frame_connector_ || surface_id_.is_null())
+  if (!frame_connector_ || local_frame_id_.is_null())
     return point;
 
   return frame_connector_->TransformPointToLocalCoordSpace(
-      point, original_surface, surface_id_);
+      point, original_surface, cc::SurfaceId(frame_sink_id_, local_frame_id_));
 }
 
 gfx::Point RenderWidgetHostViewChildFrame::TransformPointToCoordSpaceForView(
     const gfx::Point& point,
     RenderWidgetHostViewBase* target_view) {
-  if (!frame_connector_ || surface_id_.is_null() || target_view == this)
+  if (!frame_connector_ || local_frame_id_.is_null() || target_view == this)
     return point;
 
-  return frame_connector_->TransformPointToCoordSpaceForView(point, target_view,
-                                                             surface_id_);
+  return frame_connector_->TransformPointToCoordSpaceForView(
+      point, target_view, cc::SurfaceId(frame_sink_id_, local_frame_id_));
 }
 
 #if defined(OS_MACOSX)
 ui::AcceleratedWidgetMac*
 RenderWidgetHostViewChildFrame::GetAcceleratedWidgetMac() const {
   return nullptr;
 }
 
 void RenderWidgetHostViewChildFrame::SetActive(bool active) {
 }
@@ skipping 46 matching lines @@
     const SkColorType preferred_color_type) {
   DCHECK(IsSurfaceAvailableForCopy());
 
   std::unique_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateRequest(
           base::Bind(&CopyFromCompositingSurfaceHasResult, output_size,
                      preferred_color_type, callback));
   if (!src_subrect.IsEmpty())
     request->set_area(src_subrect);
 
-  surface_factory_->RequestCopyOfSurface(surface_id_, std::move(request));
+  surface_factory_->RequestCopyOfSurface(local_frame_id_, std::move(request));
 }
 
 void RenderWidgetHostViewChildFrame::CopyFromCompositingSurfaceToVideoFrame(
     const gfx::Rect& src_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(const gfx::Rect&, bool)>& callback) {
   NOTIMPLEMENTED();
   callback.Run(gfx::Rect(), false);
 }
 
@@ skipping 86 matching lines @@
 }
 
 BrowserAccessibilityManager*
 RenderWidgetHostViewChildFrame::CreateBrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate, bool for_root_frame) {
   return BrowserAccessibilityManager::Create(
       BrowserAccessibilityManager::GetEmptyDocument(), delegate);
 }
 
 void RenderWidgetHostViewChildFrame::ClearCompositorSurfaceIfNecessary() {
-  if (surface_factory_ && !surface_id_.is_null())
-    surface_factory_->Destroy(surface_id_);
-  surface_id_ = cc::SurfaceId();
+  if (surface_factory_ && !local_frame_id_.is_null())
+    surface_factory_->Destroy(local_frame_id_);
+  local_frame_id_ = cc::LocalFrameId();
 }
 
 bool RenderWidgetHostViewChildFrame::IsChildFrameForTesting() const {
   return true;
 }
 
 cc::SurfaceId RenderWidgetHostViewChildFrame::SurfaceIdForTesting() const {
-  return surface_id_;
+  return cc::SurfaceId(frame_sink_id_, local_frame_id_);
 };
 
 }  // namespace content