aura: Clean up compositor initialization/destruction.

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 2012 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/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 1206 matching lines @@
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) {
   if (!window_->layer()->has_external_content()) {
     callback.Run(false);
     return;
   }
 
+  LOG(INFO) << "SEND Frame to CopyOutputRequest";
   scoped_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateRequest(base::Bind(
           &RenderWidgetHostViewAura::
               CopyFromCompositingSurfaceHasResultForVideo,
           AsWeakPtr(),  // For caching the ReadbackYUVInterface on this class.
           target,
           callback));
   gfx::Rect src_subrect_in_pixel =
       ConvertRectToPixel(current_device_scale_factor_, src_subrect);
   request->set_area(src_subrect_in_pixel);
@@ skipping 131 matching lines @@
     const base::Time present_time = base::Time::Now();
     scoped_refptr<media::VideoFrame> frame;
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
     if (frame_subscriber()->ShouldCaptureFrame(present_time,
                                                &frame, &callback)) {
       CopyFromCompositingSurfaceToVideoFrame(
           gfx::Rect(ConvertSizeToDIP(current_surface_->device_scale_factor(),
                                      current_surface_->size())),
           frame,
           base::Bind(callback, present_time));
+      LOG(INFO) << "SEND Frame to CopyFromCompositingSurfaceToVideoFrame";
     }
   }
 
   if (!compositor) {
     ack_callback.Run(false, texture_to_return);
   } else {
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(ack_callback, false, texture_to_return));
   }
 }
@@ skipping 456 matching lines @@
 }
 
 // static
 void RenderWidgetHostViewAura::CopyFromCompositingSurfaceHasResultForVideo(
     base::WeakPtr<RenderWidgetHostViewAura> rwhva,
     scoped_refptr<media::VideoFrame> video_frame,
     const base::Callback<void(bool)>& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
 
+  LOG(INFO) << "CopyFromCompositingSurfaceHasResultForVideo";
+
   if (!rwhva)
     return;
 
   if (result->IsEmpty())
     return;
   if (result->size().IsEmpty())
     return;
 
   // Compute the dest size we want after the letterboxing resize. Make the
   // coordinates and sizes even because we letterbox in YUV space
@@ skipping 59 matching lines @@
                                              true,
                                              false));
     yuv_readback_pipeline = rwhva->yuv_readback_pipeline_.get();
   }
 
   scoped_callback_runner.Release();
   base::Callback<void(bool result)> finished_callback = base::Bind(
       &CopyFromCompositingSurfaceFinishedForVideo,
       callback,
       texture_mailbox->callback());
+  LOG(INFO) << "Pass video frame to Readback YUV";
   yuv_readback_pipeline->ReadbackYUV(
       texture_mailbox->name(),
       texture_mailbox->sync_point(),
       video_frame.get(),
       finished_callback);
+  LOG(INFO) << "Done with it here.";
 }
 
 void RenderWidgetHostViewAura::GetScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, window_->GetRootWindow() ? window_ : NULL);
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetBoundsInRootWindow() {
   return window_->GetToplevelWindow()->GetBoundsInScreen();
 }
 
@@ skipping 1222 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content