Introduce cc::LocalFrameId and use in SurfaceFactory

content/browser/frame_host/render_widget_host_view_guest.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_guest.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 94 matching lines @@
     return;
   // Make sure the size of this view matches the size of the WebContentsView.
   // The two sizes may fall out of sync if we switch RenderWidgetHostViews,
   // resize, and then switch page, as is the case with interstitial pages.
   // NOTE: |guest_| is NULL in unit tests.
   if (guest_) {
     SetSize(guest_->web_contents()->GetViewBounds().size());
     // Since we were last shown, our renderer may have had a different surface
     // set (e.g. showing an interstitial), so we resend our current surface to
     // the renderer.
-    if (!surface_id_.is_null()) {
+    if (!local_frame_id_.is_null()) {
       cc::SurfaceSequence sequence =
           cc::SurfaceSequence(frame_sink_id_, next_surface_sequence_++);
+      cc::SurfaceId surface_id(frame_sink_id_, local_frame_id_);
       GetSurfaceManager()
-          ->GetSurfaceForId(surface_id_)
+          ->GetSurfaceForId(surface_id)
           ->AddDestructionDependency(sequence);
-      guest_->SetChildFrameSurface(surface_id_, current_surface_size_,
-                                   current_surface_scale_factor_,
-                                   sequence);
+      guest_->SetChildFrameSurface(surface_id, current_surface_size_,
+                                   current_surface_scale_factor_, sequence);
     }
   }
   host_->WasShown(ui::LatencyInfo());
 }
 
 void RenderWidgetHostViewGuest::Hide() {
   // |guest_| is NULL during test.
   if ((guest_ && guest_->is_in_destruction()) || host_->is_hidden())
     return;
   host_->WasHidden();
@@ skipping 137 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_ ||
       (guest_ && guest_->has_attached_since_surface_set())) {
     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);
+    cc::SurfaceId surface_id(frame_sink_id_, local_frame_id_);
+    manager->GetSurfaceForId(surface_id)->AddDestructionDependency(sequence);
     // TODO(wjmaclean): I'm not sure what it means to create a surface id
     // without setting it on the child, though since we will in this case be
     // guaranteed to call ClearCompositorSurfaceIfNecessary() below, I suspect
     // skipping SetChildFrameSurface() here is irrelevant.
     if (guest_ && !guest_->is_in_destruction()) {
-      guest_->SetChildFrameSurface(surface_id_, frame_size, scale_factor,
+      guest_->SetChildFrameSurface(surface_id, frame_size, scale_factor,
                                    sequence);
     }
   }
 
   cc::SurfaceFactory::DrawCallback ack_callback = base::Bind(
       &RenderWidgetHostViewChildFrame::SurfaceDrawn,
       RenderWidgetHostViewChildFrame::AsWeakPtr(), compositor_frame_sink_id);
   ack_pending_count_++;
   // If this value grows very large, something is going wrong.
   DCHECK(ack_pending_count_ < 1000);
-  surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
+  surface_factory_->SubmitCompositorFrame(local_frame_id_, std::move(frame),
                                           ack_callback);
 
   ProcessFrameSwappedCallbacks();
 
   // If after detaching we are sent a frame, we should finish processing it, and
   // then we should clear the surface so that we are not holding resources we
   // no longer need.
   if (!guest_ || !guest_->attached())
     ClearCompositorSurfaceIfNecessary();
 }
@@ skipping 340 matching lines @@
         gesture_event.data.scrollUpdate.inertialPhase ==
             blink::WebGestureEvent::MomentumPhase) {
       return;
     }
     host_->ForwardGestureEvent(gesture_event);
     return;
   }
 }
 
 }  // namespace content