Use Surfaces to hold delegated renderer contents.

content/browser/compositor/delegated_frame_layer_host.cc

Index: content/browser/compositor/delegated_frame_layer_host.cc
diff --git a/content/browser/compositor/delegated_frame_host.cc b/content/browser/compositor/delegated_frame_layer_host.cc
similarity index 82%
copy from content/browser/compositor/delegated_frame_host.cc
copy to content/browser/compositor/delegated_frame_layer_host.cc
index 91c8e035ceefcbef7fe1d401eaf64c2764a0cba0..7440ba61769925767346163150545fc77ce27354 100644
--- a/content/browser/compositor/delegated_frame_host.cc
+++ b/content/browser/compositor/delegated_frame_layer_host.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/compositor/delegated_frame_host.h"
+#include "content/browser/compositor/delegated_frame_layer_host.h"
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ -11,6 +11,7 @@
 #include "cc/output/copy_output_request.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
+#include "cc/surfaces/surface_factory.h"
 #include "content/browser/compositor/resize_lock.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
@@ -22,31 +23,10 @@
 namespace content {
 
 ////////////////////////////////////////////////////////////////////////////////
-// DelegatedFrameHostClient
-
-bool DelegatedFrameHostClient::ShouldCreateResizeLock() {
-  // On Windows and Linux, holding pointer moves will not help throttling
-  // resizes.
-  // TODO(piman): on Windows we need to block (nested message loop?) the
-  // WM_SIZE event. On Linux we need to throttle at the WM level using
-  // _NET_WM_SYNC_REQUEST.
-  // TODO(ccameron): Mac browser window resizing is incompletely implemented.
-#if !defined(OS_CHROMEOS)
-  return false;
-#else
-  return GetDelegatedFrameHost()->ShouldCreateResizeLock();
-#endif
-}
-
-void DelegatedFrameHostClient::RequestCopyOfOutput(
-    scoped_ptr<cc::CopyOutputRequest> request) {
-  GetDelegatedFrameHost()->RequestCopyOfOutput(request.Pass());
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// DelegatedFrameHost
+// DelegatedFrameLayerHost
 
-DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
+DelegatedFrameLayerHost::DelegatedFrameLayerHost(
+    DelegatedFrameHostClient* client)
     : client_(client),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
@@ -56,7 +36,7 @@ DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
   ImageTransportFactory::GetInstance()->AddObserver(this);
 }
 
-void DelegatedFrameHost::WasShown() {
+void DelegatedFrameLayerHost::WasShown() {
   delegated_frame_evictor_->SetVisible(true);
 
   if (!released_front_lock_.get()) {
@@ -66,12 +46,12 @@ void DelegatedFrameHost::WasShown() {
   }
 }
 
-void DelegatedFrameHost::WasHidden() {
+void DelegatedFrameLayerHost::WasHidden() {
   delegated_frame_evictor_->SetVisible(false);
   released_front_lock_ = NULL;
 }
 
-void DelegatedFrameHost::MaybeCreateResizeLock() {
+void DelegatedFrameLayerHost::MaybeCreateResizeLock() {
   if (!client_->ShouldCreateResizeLock())
     return;
   DCHECK(client_->GetCompositor());
@@ -91,7 +71,7 @@ void DelegatedFrameHost::MaybeCreateResizeLock() {
   resize_lock_ = client_->CreateResizeLock(defer_compositor_lock);
 }
 
-bool DelegatedFrameHost::ShouldCreateResizeLock() {
+bool DelegatedFrameLayerHost::ShouldCreateResizeLock() {
   RenderWidgetHostImpl* host = client_->GetHost();
 
   if (resize_lock_)
@@ -111,12 +91,12 @@ bool DelegatedFrameHost::ShouldCreateResizeLock() {
   return true;
 }
 
-void DelegatedFrameHost::RequestCopyOfOutput(
+void DelegatedFrameLayerHost::RequestCopyOfOutput(
     scoped_ptr<cc::CopyOutputRequest> request) {
   client_->GetLayer()->RequestCopyOfOutput(request.Pass());
 }
 
-void DelegatedFrameHost::CopyFromCompositingSurface(
+void DelegatedFrameLayerHost::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
@@ -134,7 +114,7 @@ void DelegatedFrameHost::CopyFromCompositingSurface(
       client_->ConvertViewSizeToPixel(dst_size);
   scoped_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateRequest(base::Bind(
-          &DelegatedFrameHost::CopyFromCompositingSurfaceHasResult,
+          &DelegatedFrameLayerHost::CopyFromCompositingSurfaceHasResult,
           dst_size_in_pixel,
           color_type,
           callback));
@@ -144,10 +124,10 @@ void DelegatedFrameHost::CopyFromCompositingSurface(
   client_->RequestCopyOfOutput(request.Pass());
 }
 
-void DelegatedFrameHost::CopyFromCompositingSurfaceToVideoFrame(
-      const gfx::Rect& src_subrect,
-      const scoped_refptr<media::VideoFrame>& target,
-      const base::Callback<void(bool)>& callback) {
+void DelegatedFrameLayerHost::CopyFromCompositingSurfaceToVideoFrame(
+    const gfx::Rect& src_subrect,
+    const scoped_refptr<media::VideoFrame>& target,
+    const base::Callback<void(bool)>& callback) {
   if (!CanCopyToVideoFrame()) {
     callback.Run(false);
     return;
@@ -167,8 +147,7 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceToVideoFrame(
 
   scoped_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateRequest(base::Bind(
-          &DelegatedFrameHost::
-               CopyFromCompositingSurfaceHasResultForVideo,
+          &DelegatedFrameLayerHost::CopyFromCompositingSurfaceHasResultForVideo,
           AsWeakPtr(),  // For caching the ReadbackYUVInterface on this class.
           subscriber_texture,
           target,
@@ -185,54 +164,57 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceToVideoFrame(
   client_->RequestCopyOfOutput(request.Pass());
 }
 
-bool DelegatedFrameHost::CanCopyToBitmap() const {
+bool DelegatedFrameLayerHost::CanCopyToBitmap() const {
   return client_->GetCompositor() &&
          client_->GetLayer()->has_external_content();
 }
 
-bool DelegatedFrameHost::CanCopyToVideoFrame() const {
+bool DelegatedFrameLayerHost::CanCopyToVideoFrame() const {
   return client_->GetCompositor() &&
          client_->GetLayer()->has_external_content();
 }
 
-bool DelegatedFrameHost::CanSubscribeFrame() const {
+bool DelegatedFrameLayerHost::CanSubscribeFrame() const {
   return true;
 }
 
-void DelegatedFrameHost::BeginFrameSubscription(
+void DelegatedFrameLayerHost::BeginFrameSubscription(
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   frame_subscriber_ = subscriber.Pass();
 }
 
-void DelegatedFrameHost::EndFrameSubscription() {
+void DelegatedFrameLayerHost::EndFrameSubscription() {
   idle_frame_subscriber_textures_.clear();
   frame_subscriber_.reset();
 }
 
-bool DelegatedFrameHost::ShouldSkipFrame(gfx::Size size_in_dip) const {
+bool DelegatedFrameLayerHost::HasFrameSubscriber() const {
+  return frame_subscriber_;
+}
+
+bool DelegatedFrameLayerHost::ShouldSkipFrame(gfx::Size size_in_dip) const {
   // Should skip a frame only when another frame from the renderer is guaranteed
   // to replace it. Otherwise may cause hangs when the renderer is waiting for
   // the completion of latency infos (such as when taking a Snapshot.)
   if (can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
-      can_lock_compositor_ == NO_PENDING_COMMIT ||
-      !resize_lock_.get())
+      can_lock_compositor_ == NO_PENDING_COMMIT || !resize_lock_.get())
     return false;
 
   return size_in_dip != resize_lock_->expected_size();
 }
 
-void DelegatedFrameHost::WasResized() {
+void DelegatedFrameLayerHost::WasResized() {
   MaybeCreateResizeLock();
 }
 
-gfx::Size DelegatedFrameHost::GetRequestedRendererSize() const {
+gfx::Size DelegatedFrameLayerHost::GetRequestedRendererSize() const {
   if (resize_lock_)
     return resize_lock_->expected_size();
   else
     return client_->DesiredFrameSize();
 }
 
-void DelegatedFrameHost::CheckResizeLock() {
+void DelegatedFrameLayerHost::CheckResizeLock() {
   if (!resize_lock_ ||
       resize_lock_->expected_size() != current_frame_size_in_dip_)
     return;
@@ -248,13 +230,13 @@ void DelegatedFrameHost::CheckResizeLock() {
   }
 }
 
-void DelegatedFrameHost::DidReceiveFrameFromRenderer() {
+void DelegatedFrameLayerHost::DidReceiveFrameFromRenderer() {
   if (frame_subscriber() && CanCopyToVideoFrame()) {
     const base::TimeTicks present_time = base::TimeTicks::Now();
     scoped_refptr<media::VideoFrame> frame;
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
-    if (frame_subscriber()->ShouldCaptureFrame(present_time,
-                                               &frame, &callback)) {
+    if (frame_subscriber()->ShouldCaptureFrame(
+            present_time, &frame, &callback)) {
       CopyFromCompositingSurfaceToVideoFrame(
           gfx::Rect(current_frame_size_in_dip_),
           frame,
@@ -263,7 +245,7 @@ void DelegatedFrameHost::DidReceiveFrameFromRenderer() {
   }
 }
 
-void DelegatedFrameHost::SwapDelegatedFrame(
+void DelegatedFrameLayerHost::SwapDelegatedFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data,
     float frame_device_scale_factor,
@@ -288,11 +270,14 @@ void DelegatedFrameHost::SwapDelegatedFrame(
                                               &ack.resources);
 
     skipped_latency_info_list_.insert(skipped_latency_info_list_.end(),
-        latency_info.begin(), latency_info.end());
+                                      latency_info.begin(),
+                                      latency_info.end());
 
     RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-        host->GetRoutingID(), output_surface_id,
-        host->GetProcess()->GetID(), ack);
+        host->GetRoutingID(),
+        output_surface_id,
+        host->GetProcess()->GetID(),
+        ack);
     skipped_frames_ = true;
     return;
   }
@@ -369,12 +354,12 @@ void DelegatedFrameHost::SwapDelegatedFrame(
       compositor->SetLatencyInfo(*it);
     // If we've previously skipped any latency infos add them.
     for (it = skipped_latency_info_list_.begin();
-        it != skipped_latency_info_list_.end();
-        ++it)
+         it != skipped_latency_info_list_.end();
+         ++it)
       compositor->SetLatencyInfo(*it);
     skipped_latency_info_list_.clear();
     AddOnCommitCallbackAndDisableLocks(
-        base::Bind(&DelegatedFrameHost::SendDelegatedFrameAck,
+        base::Bind(&DelegatedFrameLayerHost::SendDelegatedFrameAck,
                    AsWeakPtr(),
                    output_surface_id));
   }
@@ -384,7 +369,21 @@ void DelegatedFrameHost::SwapDelegatedFrame(
   // Note: the frame may have been evicted immediately.
 }
 
-void DelegatedFrameHost::SendDelegatedFrameAck(uint32 output_surface_id) {
+void DelegatedFrameLayerHost::SetLayerOwner(ui::LayerOwner* layer_owner) {
+  layer_owner->set_layer_owner_delegate(this);
+}
+
+cc::DelegatedFrameProvider* DelegatedFrameLayerHost::FrameProviderForTesting()
+    const {
+  return frame_provider_.get();
+}
+
+void DelegatedFrameLayerHost::OnCompositingDidCommitForTesting(
+    ui::Compositor* compositor) {
+  OnCompositingDidCommit(compositor);
+}
+
+void DelegatedFrameLayerHost::SendDelegatedFrameAck(uint32 output_surface_id) {
   RenderWidgetHostImpl* host = client_->GetHost();
   cc::CompositorFrameAck ack;
   if (resource_collection_)
@@ -397,14 +396,14 @@ void DelegatedFrameHost::SendDelegatedFrameAck(uint32 output_surface_id) {
   pending_delegated_ack_count_--;
 }
 
-void DelegatedFrameHost::UnusedResourcesAreAvailable() {
+void DelegatedFrameLayerHost::UnusedResourcesAreAvailable() {
   if (pending_delegated_ack_count_)
     return;
 
   SendReturnedDelegatedResources(last_output_surface_id_);
 }
 
-void DelegatedFrameHost::SendReturnedDelegatedResources(
+void DelegatedFrameLayerHost::SendReturnedDelegatedResources(
     uint32 output_surface_id) {
   RenderWidgetHostImpl* host = client_->GetHost();
   DCHECK(resource_collection_);
@@ -420,14 +419,14 @@ void DelegatedFrameHost::SendReturnedDelegatedResources(
       ack);
 }
 
-void DelegatedFrameHost::EvictDelegatedFrame() {
+void DelegatedFrameLayerHost::EvictDelegatedFrame() {
   client_->GetLayer()->SetShowPaintedContent();
   frame_provider_ = NULL;
   delegated_frame_evictor_->DiscardedFrame();
 }
 
 // static
-void DelegatedFrameHost::CopyFromCompositingSurfaceHasResult(
+void DelegatedFrameLayerHost::CopyFromCompositingSurfaceHasResult(
     const gfx::Size& dst_size_in_pixel,
     const SkColorType color_type,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
@@ -438,15 +437,14 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceHasResult(
   }
 
   if (result->HasTexture()) {
-    PrepareTextureCopyOutputResult(dst_size_in_pixel, color_type,
-                                   callback,
-                                   result.Pass());
+    PrepareTextureCopyOutputResult(
+        dst_size_in_pixel, color_type, callback, result.Pass());
     return;
   }
 
   DCHECK(result->HasBitmap());
-  PrepareBitmapCopyOutputResult(dst_size_in_pixel, color_type, callback,
-                                result.Pass());
+  PrepareBitmapCopyOutputResult(
+      dst_size_in_pixel, color_type, callback, result.Pass());
 }
 
 static void CopyFromCompositingSurfaceFinished(
@@ -469,7 +467,7 @@ static void CopyFromCompositingSurfaceFinished(
 }
 
 // static
-void DelegatedFrameHost::PrepareTextureCopyOutputResult(
+void DelegatedFrameLayerHost::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     const SkColorType color_type,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
@@ -518,7 +516,7 @@ void DelegatedFrameHost::PrepareTextureCopyOutputResult(
 }
 
 // static
-void DelegatedFrameHost::PrepareBitmapCopyOutputResult(
+void DelegatedFrameLayerHost::PrepareBitmapCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     const SkColorType color_type,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
@@ -531,17 +529,17 @@ void DelegatedFrameHost::PrepareBitmapCopyOutputResult(
   DCHECK(result->HasBitmap());
   scoped_ptr<SkBitmap> source = result->TakeBitmap();
   DCHECK(source);
-  SkBitmap bitmap = skia::ImageOperations::Resize(
-      *source,
-      skia::ImageOperations::RESIZE_BEST,
-      dst_size_in_pixel.width(),
-      dst_size_in_pixel.height());
+  SkBitmap bitmap =
+      skia::ImageOperations::Resize(*source,
+                                    skia::ImageOperations::RESIZE_BEST,
+                                    dst_size_in_pixel.width(),
+                                    dst_size_in_pixel.height());
   callback.Run(true, bitmap);
 }
 
 // static
-void DelegatedFrameHost::ReturnSubscriberTexture(
-    base::WeakPtr<DelegatedFrameHost> dfh,
+void DelegatedFrameLayerHost::ReturnSubscriberTexture(
+    base::WeakPtr<DelegatedFrameLayerHost> dfh,
     scoped_refptr<OwnedMailbox> subscriber_texture,
     uint32 sync_point) {
   if (!subscriber_texture.get())
@@ -555,8 +553,8 @@ void DelegatedFrameHost::ReturnSubscriberTexture(
     dfh->idle_frame_subscriber_textures_.push_back(subscriber_texture);
 }
 
-void DelegatedFrameHost::CopyFromCompositingSurfaceFinishedForVideo(
-    base::WeakPtr<DelegatedFrameHost> dfh,
+void DelegatedFrameLayerHost::CopyFromCompositingSurfaceFinishedForVideo(
+    base::WeakPtr<DelegatedFrameLayerHost> dfh,
     const base::Callback<void(bool)>& callback,
     scoped_refptr<OwnedMailbox> subscriber_texture,
     scoped_ptr<cc::SingleReleaseCallback> release_callback,
@@ -579,8 +577,8 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceFinishedForVideo(
 }
 
 // static
-void DelegatedFrameHost::CopyFromCompositingSurfaceHasResultForVideo(
-    base::WeakPtr<DelegatedFrameHost> dfh,
+void DelegatedFrameLayerHost::CopyFromCompositingSurfaceHasResultForVideo(
+    base::WeakPtr<DelegatedFrameLayerHost> dfh,
     scoped_refptr<OwnedMailbox> subscriber_texture,
     scoped_refptr<media::VideoFrame> video_frame,
     const base::Callback<void(bool)>& callback,
@@ -602,9 +600,8 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceHasResultForVideo(
   // line up correctly.
   // The video frame's coded_size() and the result's size() are both physical
   // pixels.
-  gfx::Rect region_in_frame =
-      media::ComputeLetterboxRegion(gfx::Rect(video_frame->coded_size()),
-                                    result->size());
+  gfx::Rect region_in_frame = media::ComputeLetterboxRegion(
+      gfx::Rect(video_frame->coded_size()), result->size());
   region_in_frame = gfx::Rect(region_in_frame.x() & ~1,
                               region_in_frame.y() & ~1,
                               region_in_frame.width() & ~1,
@@ -621,7 +618,8 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceHasResultForVideo(
         result->size().height() != region_in_frame.height()) {
       skia::ImageOperations::ResizeMethod method =
           skia::ImageOperations::RESIZE_GOOD;
-      scaled_bitmap = skia::ImageOperations::Resize(*bitmap.get(), method,
+      scaled_bitmap = skia::ImageOperations::Resize(*bitmap.get(),
+                                                    method,
                                                     region_in_frame.width(),
                                                     region_in_frame.height());
     } else {
@@ -692,7 +690,7 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceHasResultForVideo(
   ignore_result(scoped_callback_runner.Release());
   ignore_result(scoped_return_subscriber_texture.Release());
   base::Callback<void(bool result)> finished_callback = base::Bind(
-      &DelegatedFrameHost::CopyFromCompositingSurfaceFinishedForVideo,
+      &DelegatedFrameLayerHost::CopyFromCompositingSurfaceFinishedForVideo,
       dfh->AsWeakPtr(),
       callback,
       subscriber_texture,
@@ -704,9 +702,9 @@ void DelegatedFrameHost::CopyFromCompositingSurfaceHasResultForVideo(
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// DelegatedFrameHost, ui::CompositorObserver implementation:
+// DelegatedFrameLayerHost, ui::CompositorObserver implementation:
 
-void DelegatedFrameHost::OnCompositingDidCommit(
+void DelegatedFrameLayerHost::OnCompositingDidCommit(
     ui::Compositor* compositor) {
   RenderWidgetHostImpl* host = client_->GetHost();
   if (can_lock_compositor_ == NO_PENDING_COMMIT) {
@@ -726,19 +724,18 @@ void DelegatedFrameHost::OnCompositingDidCommit(
   }
 }
 
-void DelegatedFrameHost::OnCompositingStarted(
-    ui::Compositor* compositor, base::TimeTicks start_time) {
+void DelegatedFrameLayerHost::OnCompositingStarted(ui::Compositor* compositor,
+                                                   base::TimeTicks start_time) {
   last_draw_ended_ = start_time;
 }
 
-void DelegatedFrameHost::OnCompositingEnded(
-    ui::Compositor* compositor) {
+void DelegatedFrameLayerHost::OnCompositingEnded(ui::Compositor* compositor) {
 }
 
-void DelegatedFrameHost::OnCompositingAborted(ui::Compositor* compositor) {
+void DelegatedFrameLayerHost::OnCompositingAborted(ui::Compositor* compositor) {
 }
 
-void DelegatedFrameHost::OnCompositingLockStateChanged(
+void DelegatedFrameLayerHost::OnCompositingLockStateChanged(
     ui::Compositor* compositor) {
   // A compositor lock that is part of a resize lock timed out. We
   // should display a renderer frame.
@@ -747,7 +744,7 @@ void DelegatedFrameHost::OnCompositingLockStateChanged(
   }
 }
 
-void DelegatedFrameHost::OnUpdateVSyncParameters(
+void DelegatedFrameLayerHost::OnUpdateVSyncParameters(
     base::TimeTicks timebase,
     base::TimeDelta interval) {
   RenderWidgetHostImpl* host = client_->GetHost();
@@ -758,7 +755,7 @@ void DelegatedFrameHost::OnUpdateVSyncParameters(
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ImageTransportFactoryObserver implementation:
 
-void DelegatedFrameHost::OnLostResources() {
+void DelegatedFrameLayerHost::OnLostResources() {
   RenderWidgetHostImpl* host = client_->GetHost();
   if (frame_provider_.get())
     EvictDelegatedFrame();
@@ -769,9 +766,9 @@ void DelegatedFrameHost::OnLostResources() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// DelegatedFrameHost, private:
+// DelegatedFrameLayerHost, private:
 
-DelegatedFrameHost::~DelegatedFrameHost() {
+DelegatedFrameLayerHost::~DelegatedFrameLayerHost() {
   ImageTransportFactory::GetInstance()->RemoveObserver(this);
 
   if (resource_collection_.get())
@@ -780,16 +777,17 @@ DelegatedFrameHost::~DelegatedFrameHost() {
   DCHECK(!vsync_manager_);
 }
 
-void DelegatedFrameHost::RunOnCommitCallbacks() {
-  for (std::vector<base::Closure>::const_iterator
-      it = on_compositing_did_commit_callbacks_.begin();
-      it != on_compositing_did_commit_callbacks_.end(); ++it) {
+void DelegatedFrameLayerHost::RunOnCommitCallbacks() {
+  for (std::vector<base::Closure>::const_iterator it =
+           on_compositing_did_commit_callbacks_.begin();
+       it != on_compositing_did_commit_callbacks_.end();
+       ++it) {
     it->Run();
   }
   on_compositing_did_commit_callbacks_.clear();
 }
 
-void DelegatedFrameHost::AddOnCommitCallbackAndDisableLocks(
+void DelegatedFrameLayerHost::AddOnCommitCallbackAndDisableLocks(
     const base::Closure& callback) {
   ui::Compositor* compositor = client_->GetCompositor();
   DCHECK(compositor);
@@ -801,7 +799,7 @@ void DelegatedFrameHost::AddOnCommitCallbackAndDisableLocks(
   on_compositing_did_commit_callbacks_.push_back(callback);
 }
 
-void DelegatedFrameHost::AddedToWindow() {
+void DelegatedFrameLayerHost::AddedToWindow() {
   ui::Compositor* compositor = client_->GetCompositor();
   if (compositor) {
     DCHECK(!vsync_manager_);
@@ -810,7 +808,7 @@ void DelegatedFrameHost::AddedToWindow() {
   }
 }
 
-void DelegatedFrameHost::RemovingFromWindow() {
+void DelegatedFrameLayerHost::RemovingFromWindow() {
   RunOnCommitCallbacks();
   resize_lock_.reset();
   client_->GetHost()->WasResized();
@@ -824,21 +822,21 @@ void DelegatedFrameHost::RemovingFromWindow() {
   }
 }
 
-void DelegatedFrameHost::LockResources() {
+void DelegatedFrameLayerHost::LockResources() {
   DCHECK(frame_provider_);
   delegated_frame_evictor_->LockFrame();
 }
 
-void DelegatedFrameHost::UnlockResources() {
+void DelegatedFrameLayerHost::UnlockResources() {
   DCHECK(frame_provider_);
   delegated_frame_evictor_->UnlockFrame();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// DelegatedFrameHost, ui::LayerOwnerDelegate implementation:
+// DelegatedFrameLayerHost, ui::LayerOwnerDelegate implementation:
 
-void DelegatedFrameHost::OnLayerRecreated(ui::Layer* old_layer,
-                                                ui::Layer* new_layer) {
+void DelegatedFrameLayerHost::OnLayerRecreated(ui::Layer* old_layer,
+                                               ui::Layer* new_layer) {
   // The new_layer is the one that will be used by our Window, so that's the one
   // that should keep our frame. old_layer will be returned to the
   // RecreateLayer caller, and should have a copy.
@@ -849,4 +847,3 @@ void DelegatedFrameHost::OnLayerRecreated(ui::Layer* old_layer,
 }
 
 }  // namespace content
-