[WIP] cc: Plumb SurfaceId from clients

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 23 matching lines @@
 #include "content/public/common/browser_plugin_guest_mode.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/size_f.h"
 
 namespace content {
 
 RenderWidgetHostViewChildFrame::RenderWidgetHostViewChildFrame(
     RenderWidgetHost* widget_host)
     : host_(RenderWidgetHostImpl::From(widget_host)),
+      surface_client_id_(AllocateSurfaceClientId()),
       next_surface_sequence_(1u),
       last_output_surface_id_(0),
       current_surface_scale_factor_(1.f),
       ack_pending_count_(0),
       frame_connector_(nullptr),
       begin_frame_source_(nullptr),
       observing_begin_frame_source_(false),
       parent_surface_client_id_(0),
       weak_factory_(this) {
-  id_allocator_ = CreateSurfaceIdAllocator();
+  cc::SurfaceManager* manager = GetSurfaceManager();
+  surface_factory_ = base::WrapUnique(
+      new cc::SurfaceFactory(surface_client_id_, manager, this));
   RegisterSurfaceNamespaceId();
 
   host_->SetView(this);
 }
 
 RenderWidgetHostViewChildFrame::~RenderWidgetHostViewChildFrame() {
   if (!surface_id_.is_null())
     surface_factory_->Destroy(surface_id_);
 }
 
 void RenderWidgetHostViewChildFrame::SetCrossProcessFrameConnector(
     CrossProcessFrameConnector* frame_connector) {
   if (frame_connector_ == frame_connector)
     return;
 
   if (frame_connector_) {
-    if (parent_surface_client_id_) {
-      GetSurfaceManager()->UnregisterSurfaceNamespaceHierarchy(
-          parent_surface_client_id_, GetSurfaceClientId());
-    }
-    // Unregister the client here, as it is not guaranteed in tests that the
-    // destructor will be called.
-    GetSurfaceManager()->UnregisterSurfaceFactoryClient(
-        id_allocator_->client_id());
-
+    surface_factory_.reset();
     parent_surface_client_id_ = 0;
 
     // After the RenderWidgetHostViewChildFrame loses the frame_connector, it
     // won't be able to walk up the frame tree anymore. Clean up anything that
     // needs to be done through the CrossProcessFrameConnector before it's gone.
 
     // Unlocks the mouse if this RenderWidgetHostView holds the lock.
     UnlockMouse();
   }
   frame_connector_ = frame_connector;
   if (frame_connector_) {
-    GetSurfaceManager()->RegisterSurfaceFactoryClient(
-        id_allocator_->client_id(), this);
+    cc::SurfaceManager* manager = GetSurfaceManager();
+    surface_factory_.reset(
+        new cc::SurfaceFactory(surface_client_id_, manager, this));
     RenderWidgetHostViewBase* parent_view =
         frame_connector_->GetParentRenderWidgetHostView();
     if (parent_view) {
       parent_surface_client_id_ = parent_view->GetSurfaceClientId();
       DCHECK_NE(parent_surface_client_id_, 0u);
-      GetSurfaceManager()->RegisterSurfaceNamespaceHierarchy(
-          parent_surface_client_id_, GetSurfaceClientId());
+      surface_factory_->SetParent(parent_surface_client_id_);
     }
   }
 }
 
 void RenderWidgetHostViewChildFrame::InitAsChild(
     gfx::NativeView parent_view) {
   NOTREACHED();
 }
 
 bool RenderWidgetHostViewChildFrame::OnMessageReceived(
@@ skipping 241 matching lines @@
     host_->Send(new ViewMsg_ReclaimCompositorResources(
         host_->GetRoutingID(), output_surface_id, true /* is_swap_ack */,
         surface_returned_resources_));
     surface_returned_resources_.clear();
   }
   ack_pending_count_--;
 }
 
 void RenderWidgetHostViewChildFrame::OnSwapCompositorFrame(
     uint32_t output_surface_id,
+    const cc::SurfaceId& surface_id,
     cc::CompositorFrame frame) {
   TRACE_EVENT0("content",
                "RenderWidgetHostViewChildFrame::OnSwapCompositorFrame");
 
   last_scroll_offset_ = frame.metadata.root_scroll_offset;
 
   if (!frame_connector_)
     return;
 
   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;
+  current_surface_scale_factor_ = scale_factor;
+  current_surface_size_ = frame_size;
 
   // 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 (output_surface_id != last_output_surface_id_ && surface_factory_) {
-    surface_factory_->Destroy(surface_id_);
-    surface_factory_.reset();
-  }
-  if (output_surface_id != last_output_surface_id_ ||
-      frame_size != current_surface_size_ ||
-      scale_factor != current_surface_scale_factor_) {
-    ClearCompositorSurfaceIfNecessary();
+  if (output_surface_id != last_output_surface_id_) {
+    if (surface_factory_)
+      surface_factory_->DestroyAll();
     last_output_surface_id_ = output_surface_id;
-    current_surface_size_ = frame_size;
-    current_surface_scale_factor_ = scale_factor;
   }
 
   if (!surface_factory_) {
     cc::SurfaceManager* manager = GetSurfaceManager();
-    surface_factory_ = base::WrapUnique(new cc::SurfaceFactory(manager, this));
+    surface_factory_ = base::WrapUnique(
+        new cc::SurfaceFactory(surface_client_id_, manager, this));
   }
 
-  if (surface_id_.is_null()) {
-    surface_id_ = id_allocator_->GenerateId();
-    surface_factory_->Create(surface_id_);
+  if (surface_id_ != surface_id) {
+    if (!surface_id_.is_null())
+      surface_factory_->Destroy(surface_id_);
 
-    cc::SurfaceSequence sequence = cc::SurfaceSequence(
-        id_allocator_->client_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);
+    surface_id_ = surface_id;
+    if (!surface_id.is_null()) {
+      surface_factory_->Create(surface_id);
+
+      cc::SurfaceSequence sequence =
+          cc::SurfaceSequence(surface_client_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);
+    }
   }
 
   cc::SurfaceFactory::DrawCallback ack_callback =
       base::Bind(&RenderWidgetHostViewChildFrame::SurfaceDrawn, AsWeakPtr(),
                  output_surface_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),
                                           ack_callback);
@@ skipping 52 matching lines @@
 }
 
 bool RenderWidgetHostViewChildFrame::IsMouseLocked() {
   if (!host_->delegate())
     return false;
 
   return host_->delegate()->HasMouseLock(host_);
 }
 
 uint32_t RenderWidgetHostViewChildFrame::GetSurfaceClientId() {
-  return id_allocator_->client_id();
+  return surface_client_id_;
 }
 
 void RenderWidgetHostViewChildFrame::ProcessKeyboardEvent(
     const NativeWebKeyboardEvent& event) {
   host_->ForwardKeyboardEvent(event);
 }
 
 void RenderWidgetHostViewChildFrame::ProcessMouseEvent(
     const blink::WebMouseEvent& event,
     const ui::LatencyInfo& latency) {
@@ skipping 187 matching lines @@
 
 bool RenderWidgetHostViewChildFrame::IsChildFrameForTesting() const {
   return true;
 }
 
 cc::SurfaceId RenderWidgetHostViewChildFrame::SurfaceIdForTesting() const {
   return surface_id_;
 };
 
 }  // namespace content