[WIP] cc: Plumb SurfaceId from clients

content/browser/renderer_host/delegated_frame_host.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/renderer_host/delegated_frame_host.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
+#include "base/debug/stack_trace.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/default_tick_clock.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_hittest.h"
 #include "cc/surfaces/surface_manager.h"
@@ skipping 39 matching lines @@
 // DelegatedFrameHost
 
 DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
     : client_(client),
       compositor_(nullptr),
       tick_clock_(new base::DefaultTickClock()),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       background_color_(SK_ColorRED),
+      surface_client_id_(0),
       current_scale_factor_(1.f),
       can_lock_compositor_(YES_CAN_LOCK),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
+  ImageTransportFactory* context_factory = ImageTransportFactory::GetInstance();
+  context_factory->GetContextFactory()->AddObserver(this);
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
-  factory->GetContextFactory()->AddObserver(this);
-  id_allocator_ = factory->GetContextFactory()->CreateSurfaceIdAllocator();
-  factory->GetSurfaceManager()->RegisterSurfaceFactoryClient(
-      id_allocator_->client_id(), this);
+  cc::SurfaceManager* manager = factory->GetSurfaceManager();
+  surface_client_id_ = factory->GetContextFactory()->AllocateSurfaceClientId();
+  surface_factory_ = base::WrapUnique(
+      new cc::SurfaceFactory(surface_client_id_, manager, this));
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
   delegated_frame_evictor_->SetVisible(true);
 
   if (surface_id_.is_null() && !released_front_lock_.get()) {
     if (compositor_)
       released_front_lock_ = compositor_->GetCompositorLock();
   }
 
@@ skipping 106 matching lines @@
     std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   frame_subscriber_ = std::move(subscriber);
 }
 
 void DelegatedFrameHost::EndFrameSubscription() {
   idle_frame_subscriber_textures_.clear();
   frame_subscriber_.reset();
 }
 
 uint32_t DelegatedFrameHost::GetSurfaceClientId() {
-  return id_allocator_->client_id();
+  return surface_client_id_;
 }
 
 cc::SurfaceId DelegatedFrameHost::SurfaceIdAtPoint(
     cc::SurfaceHittestDelegate* delegate,
     const gfx::Point& point,
     gfx::Point* transformed_point) {
   if (surface_id_.is_null())
     return surface_id_;
   cc::SurfaceHittest hittest(delegate, GetSurfaceManager());
   gfx::Transform target_transform;
@@ skipping 147 matching lines @@
   // DelegatedFrameHost (e.g., a call to CopyFromCompositingSurface() for
   // screenshots) since those copy requests do not specify |frame_subscriber()|
   // as a source.
   request->set_source(frame_subscriber());
   if (subscriber_texture.get()) {
     request->SetTextureMailbox(cc::TextureMailbox(
         subscriber_texture->mailbox(), subscriber_texture->sync_token(),
         subscriber_texture->target()));
   }
 
-  if (surface_factory_.get()) {
+  if (surface_factory_) {
     // To avoid unnecessary composites, go directly to the Surface rather than
     // through RequestCopyOfOutput (which goes through the browser
     // compositor).
     if (!request_copy_of_output_callback_for_testing_.is_null())
       request_copy_of_output_callback_for_testing_.Run(std::move(request));
     else
       surface_factory_->RequestCopyOfSurface(surface_id_, std::move(request));
   } else {
     request->set_area(gfx::Rect(current_frame_size_in_dip_));
     RequestCopyOfOutput(std::move(request));
   }
 }
 
 void DelegatedFrameHost::SwapDelegatedFrame(uint32_t output_surface_id,
+                                            const cc::SurfaceId& surface_id,
                                             cc::CompositorFrame frame) {
   DCHECK(frame.delegated_frame_data.get());
 #if defined(OS_CHROMEOS)
   DCHECK(!resize_lock_ || !client_->IsAutoResizeEnabled());
 #endif
   cc::DelegatedFrameData* frame_data = frame.delegated_frame_data.get();
   float frame_device_scale_factor = frame.metadata.device_scale_factor;
 
   DCHECK(!frame_data->render_pass_list.empty());
 
@@ skipping 27 matching lines @@
     skipped_frames_ = false;
     damage_rect = gfx::Rect(frame_size);
     damage_rect_in_dip = gfx::Rect(frame_size_in_dip);
 
     // Give the same damage rect to the compositor.
     cc::RenderPass* root_pass = frame_data->render_pass_list.back().get();
     root_pass->damage_rect = damage_rect;
   }
 
   if (output_surface_id != last_output_surface_id_) {
+    // The surface_id should change if we have a new output surface. If it
+    // hasn't then the client is misbehaving and we should just ignore the swap.
+    if (surface_id_ == surface_id)
+      return;
     // Resource ids are scoped by the output surface.
     // If the originating output surface doesn't match the last one, it
     // indicates the renderer's output surface may have been recreated, in which
     // case we should recreate the DelegatedRendererLayer, to avoid matching
     // resources from the old one with resources from the new one which would
     // have the same id. Changing the layer to showing painted content destroys
     // the DelegatedRendererLayer.
     EvictDelegatedFrame();
 
-    surface_factory_.reset();
     if (!surface_returned_resources_.empty()) {
       SendReclaimCompositorResources(last_output_surface_id_,
                                      false /* is_swap_ack */);
     }
     last_output_surface_id_ = output_surface_id;
   }
   bool skip_frame = false;
   pending_delegated_ack_count_++;
 
   background_color_ = frame.metadata.root_background_color;
 
   if (frame_size.IsEmpty()) {
     DCHECK(frame_data->resource_list.empty());
     EvictDelegatedFrame();
   } else {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     cc::SurfaceManager* manager = factory->GetSurfaceManager();
-    if (!surface_factory_) {
-      surface_factory_ =
-          base::WrapUnique(new cc::SurfaceFactory(manager, this));
-    }
-    if (surface_id_.is_null() || frame_size != current_surface_size_ ||
-        frame_size_in_dip != current_frame_size_in_dip_) {
+
+    if (surface_id_ != surface_id) {
       if (!surface_id_.is_null())
         surface_factory_->Destroy(surface_id_);
-      surface_id_ = id_allocator_->GenerateId();
+      surface_id_ = cc::SurfaceId(surface_client_id_, surface_id.local_id(),
+                                  surface_id.nonce());
       surface_factory_->Create(surface_id_);
       // manager must outlive compositors using it.
       client_->DelegatedFrameHostGetLayer()->SetShowSurface(
           surface_id_, base::Bind(&SatisfyCallback, base::Unretained(manager)),
           base::Bind(&RequireCallback, base::Unretained(manager)), frame_size,
           frame_device_scale_factor, frame_size_in_dip);
-      current_surface_size_ = frame_size;
-      current_scale_factor_ = frame_device_scale_factor;
     }
 
     frame.metadata.latency_info.insert(frame.metadata.latency_info.end(),
                                        skipped_latency_info_list_.begin(),
                                        skipped_latency_info_list_.end());
     skipped_latency_info_list_.clear();
 
     gfx::Size desired_size = client_->DelegatedFrameHostDesiredSizeInDIP();
     if (desired_size != frame_size_in_dip && !desired_size.IsEmpty())
       skip_frame = true;
@@ skipping 79 matching lines @@
 void DelegatedFrameHost::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   client_->SetBeginFrameSource(begin_frame_source);
 }
 
 void DelegatedFrameHost::EvictDelegatedFrame() {
   client_->DelegatedFrameHostGetLayer()->SetShowSolidColorContent();
   if (!surface_id_.is_null()) {
     surface_factory_->Destroy(surface_id_);
     surface_id_ = cc::SurfaceId();
+
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    surface_client_id_ =
+        factory->GetContextFactory()->AllocateSurfaceClientId();
+    cc::SurfaceManager* manager = factory->GetSurfaceManager();
+    uint32_t parent = surface_factory_->parent_client_id();
+    surface_factory_.reset(
+        new cc::SurfaceFactory(surface_client_id_, manager, this));
+    surface_factory_->SetParent(parent);
   }
   delegated_frame_evictor_->DiscardedFrame();
   UpdateGutters();
 }
 
 // static
 void DelegatedFrameHost::ReturnSubscriberTexture(
     base::WeakPtr<DelegatedFrameHost> dfh,
     scoped_refptr<OwnedMailbox> subscriber_texture,
     const gpu::SyncToken& sync_token) {
@@ skipping 150 matching lines @@
       video_frame->data(media::VideoFrame::kUPlane),
       video_frame->stride(media::VideoFrame::kVPlane),
       video_frame->data(media::VideoFrame::kVPlane), region_in_frame.origin(),
       finished_callback);
   media::LetterboxYUV(video_frame.get(), region_in_frame);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::CompositorObserver implementation:
 
+void DelegatedFrameHost::OnCompositingInitialized(ui::Compositor* compositor) {
+  uint32_t parent = compositor->surface_id_allocator()->client_id();
+  surface_factory_->SetParent(parent);
+}
+
 void DelegatedFrameHost::OnCompositingDidCommit(ui::Compositor* compositor) {
   if (can_lock_compositor_ == NO_PENDING_COMMIT) {
     can_lock_compositor_ = YES_CAN_LOCK;
     if (resize_lock_.get() && resize_lock_->GrabDeferredLock())
       can_lock_compositor_ = YES_DID_LOCK;
   }
   if (resize_lock_ &&
       resize_lock_->expected_size() == current_frame_size_in_dip_) {
     resize_lock_.reset();
     client_->DelegatedFrameHostResizeLockWasReleased();
@@ skipping 50 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, private:
 
 DelegatedFrameHost::~DelegatedFrameHost() {
   DCHECK(!compositor_);
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->GetContextFactory()->RemoveObserver(this);
 
   if (!surface_id_.is_null())
     surface_factory_->Destroy(surface_id_);
-  factory->GetSurfaceManager()->UnregisterSurfaceFactoryClient(
-      id_allocator_->client_id());
 
   DCHECK(!vsync_manager_.get());
 }
 
 void DelegatedFrameHost::SetCompositor(ui::Compositor* compositor) {
   DCHECK(!compositor_);
   if (!compositor)
     return;
   compositor_ = compositor;
   compositor_->AddObserver(this);
   DCHECK(!vsync_manager_.get());
   vsync_manager_ = compositor_->vsync_manager();
   vsync_manager_->AddObserver(this);
 
-  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
-  uint32_t parent = compositor->surface_id_allocator()->client_id();
-  factory->GetSurfaceManager()->RegisterSurfaceNamespaceHierarchy(
-      parent, id_allocator_->client_id());
+  if (compositor->initialized()) {
+    uint32_t parent = compositor->surface_id_allocator()->client_id();
+    surface_factory_->SetParent(parent);
+  }
 }
 
 void DelegatedFrameHost::ResetCompositor() {
   if (!compositor_)
     return;
   if (resize_lock_) {
     resize_lock_.reset();
     client_->DelegatedFrameHostResizeLockWasReleased();
   }
   if (compositor_->HasObserver(this))
     compositor_->RemoveObserver(this);
   if (vsync_manager_.get()) {
     vsync_manager_->RemoveObserver(this);
     vsync_manager_ = NULL;
   }
 
-  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
-  uint32_t parent = compositor_->surface_id_allocator()->client_id();
-  factory->GetSurfaceManager()->UnregisterSurfaceNamespaceHierarchy(
-      parent, id_allocator_->client_id());
+  surface_factory_->SetParent(0);
 
   compositor_ = nullptr;
 }
 
 void DelegatedFrameHost::SetVSyncParameters(const base::TimeTicks& timebase,
                                             const base::TimeDelta& interval) {
   vsync_timebase_ = timebase;
   vsync_interval_ = interval;
 }
 
@@ skipping 30 matching lines @@
     cc::SurfaceManager* manager = factory->GetSurfaceManager();
     new_layer->SetShowSurface(
         surface_id_, base::Bind(&SatisfyCallback, base::Unretained(manager)),
         base::Bind(&RequireCallback, base::Unretained(manager)),
         current_surface_size_, current_scale_factor_,
         current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content