Rename LocalFrameId to LocalSurfaceId

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 130 matching lines @@
 void RenderWidgetHostViewChildFrame::Focus() {
 }
 
 bool RenderWidgetHostViewChildFrame::HasFocus() const {
   if (frame_connector_)
     return frame_connector_->HasFocus();
   return false;
 }
 
 bool RenderWidgetHostViewChildFrame::IsSurfaceAvailableForCopy() const {
-  return local_frame_id_.is_valid();
+  return local_surface_id_.is_valid();
 }
 
 void RenderWidgetHostViewChildFrame::Show() {
   if (!host_->is_hidden())
     return;
   host_->WasShown(ui::LatencyInfo());
 }
 
 void RenderWidgetHostViewChildFrame::Hide() {
   if (host_->is_hidden())
@@ skipping 229 matching lines @@
     ClearCompositorSurfaceIfNecessary();
     // If the renderer changed its frame sink, reset the surface factory to
     // avoid returning stale resources.
     if (compositor_frame_sink_id != last_compositor_frame_sink_id_)
       surface_factory_->Reset();
     last_compositor_frame_sink_id_ = compositor_frame_sink_id;
     current_surface_size_ = frame.render_pass_list.back()->output_rect.size();
     current_surface_scale_factor_ = frame.metadata.device_scale_factor;
   }
 
-  bool allocated_new_local_frame_id = false;
-  if (!local_frame_id_.is_valid()) {
-    local_frame_id_ = id_allocator_->GenerateId();
-    allocated_new_local_frame_id = true;
+  bool allocated_new_local_surface_id = false;
+  if (!local_surface_id_.is_valid()) {
+    local_surface_id_ = id_allocator_->GenerateId();
+    allocated_new_local_surface_id = true;
   }
 
   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(local_frame_id_, std::move(frame),
+  surface_factory_->SubmitCompositorFrame(local_surface_id_, std::move(frame),
                                           ack_callback);
-  if (allocated_new_local_frame_id)
+  if (allocated_new_local_surface_id)
     SendSurfaceInfoToEmbedder();
   ProcessFrameSwappedCallbacks();
 }
 
 void RenderWidgetHostViewChildFrame::SendSurfaceInfoToEmbedder() {
   cc::SurfaceSequence sequence =
       cc::SurfaceSequence(frame_sink_id_, next_surface_sequence_++);
   cc::SurfaceManager* manager = GetSurfaceManager();
-  cc::SurfaceId surface_id(frame_sink_id_, local_frame_id_);
+  cc::SurfaceId surface_id(frame_sink_id_, local_surface_id_);
   // The renderer process will satisfy this dependency when it creates a
   // SurfaceLayer.
   manager->GetSurfaceForId(surface_id)->AddDestructionDependency(sequence);
   cc::SurfaceInfo surface_info(surface_id, current_surface_scale_factor_,
                                current_surface_size_);
   SendSurfaceInfoToEmbedderImpl(surface_info, sequence);
 }
 
 void RenderWidgetHostViewChildFrame::SendSurfaceInfoToEmbedderImpl(
     const cc::SurfaceInfo& surface_info,
@@ skipping 96 matching lines @@
 }
 
 void RenderWidgetHostViewChildFrame::ProcessGestureEvent(
     const blink::WebGestureEvent& event,
     const ui::LatencyInfo& latency) {
   host_->ForwardGestureEventWithLatencyInfo(event, latency);
 }
 
 gfx::Point RenderWidgetHostViewChildFrame::TransformPointToRootCoordSpace(
     const gfx::Point& point) {
-  if (!frame_connector_ || !local_frame_id_.is_valid())
+  if (!frame_connector_ || !local_surface_id_.is_valid())
     return point;
 
   return frame_connector_->TransformPointToRootCoordSpace(
-      point, cc::SurfaceId(frame_sink_id_, local_frame_id_));
+      point, cc::SurfaceId(frame_sink_id_, local_surface_id_));
 }
 
 bool RenderWidgetHostViewChildFrame::TransformPointToLocalCoordSpace(
     const gfx::Point& point,
     const cc::SurfaceId& original_surface,
     gfx::Point* transformed_point) {
   *transformed_point = point;
-  if (!frame_connector_ || !local_frame_id_.is_valid())
+  if (!frame_connector_ || !local_surface_id_.is_valid())
     return false;
 
   return frame_connector_->TransformPointToLocalCoordSpace(
-      point, original_surface, cc::SurfaceId(frame_sink_id_, local_frame_id_),
+      point, original_surface, cc::SurfaceId(frame_sink_id_, local_surface_id_),
       transformed_point);
 }
 
 bool RenderWidgetHostViewChildFrame::TransformPointToCoordSpaceForView(
     const gfx::Point& point,
     RenderWidgetHostViewBase* target_view,
     gfx::Point* transformed_point) {
-  if (!frame_connector_ || !local_frame_id_.is_valid())
+  if (!frame_connector_ || !local_surface_id_.is_valid())
     return false;
 
   if (target_view == this) {
     *transformed_point = point;
     return true;
   }
 
   return frame_connector_->TransformPointToCoordSpaceForView(
-      point, target_view, cc::SurfaceId(frame_sink_id_, local_frame_id_),
+      point, target_view, cc::SurfaceId(frame_sink_id_, local_surface_id_),
       transformed_point);
 }
 
 bool RenderWidgetHostViewChildFrame::IsRenderWidgetHostViewChildFrame() {
   return true;
 }
 
 #if defined(OS_MACOSX)
 ui::AcceleratedWidgetMac*
 RenderWidgetHostViewChildFrame::GetAcceleratedWidgetMac() const {
@@ skipping 159 matching lines @@
 
 BrowserAccessibilityManager*
 RenderWidgetHostViewChildFrame::CreateBrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate, bool for_root_frame) {
   return BrowserAccessibilityManager::Create(
       BrowserAccessibilityManager::GetEmptyDocument(), delegate);
 }
 
 void RenderWidgetHostViewChildFrame::ClearCompositorSurfaceIfNecessary() {
   surface_factory_->EvictSurface();
-  local_frame_id_ = cc::LocalFrameId();
+  local_surface_id_ = cc::LocalSurfaceId();
 }
 
 bool RenderWidgetHostViewChildFrame::IsChildFrameForTesting() const {
   return true;
 }
 
 cc::SurfaceId RenderWidgetHostViewChildFrame::SurfaceIdForTesting() const {
-  return cc::SurfaceId(frame_sink_id_, local_frame_id_);
+  return cc::SurfaceId(frame_sink_id_, local_surface_id_);
 };
 
 }  // namespace content