Home | History | Annotate | Download | only in renderer_host 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/browser/renderer_host/compositor_impl_android.h"
      6 
      7 #include <android/bitmap.h>
      8 #include <android/native_window_jni.h>
      9 
     10 #include "base/android/jni_android.h"
     11 #include "base/android/scoped_java_ref.h"
     12 #include "base/bind.h"
     13 #include "base/command_line.h"
     14 #include "base/containers/hash_tables.h"
     15 #include "base/lazy_instance.h"
     16 #include "base/logging.h"
     17 #include "base/single_thread_task_runner.h"
     18 #include "base/synchronization/lock.h"
     19 #include "base/threading/thread.h"
     20 #include "base/threading/thread_checker.h"
     21 #include "cc/base/switches.h"
     22 #include "cc/input/input_handler.h"
     23 #include "cc/layers/layer.h"
     24 #include "cc/output/compositor_frame.h"
     25 #include "cc/output/context_provider.h"
     26 #include "cc/output/output_surface.h"
     27 #include "cc/trees/layer_tree_host.h"
     28 #include "content/browser/android/child_process_launcher_android.h"
     29 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
     30 #include "content/browser/gpu/gpu_surface_tracker.h"
     31 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
     32 #include "content/common/gpu/client/context_provider_command_buffer.h"
     33 #include "content/common/gpu/client/gl_helper.h"
     34 #include "content/common/gpu/client/gpu_channel_host.h"
     35 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
     36 #include "content/common/gpu/gpu_process_launch_causes.h"
     37 #include "content/common/host_shared_bitmap_manager.h"
     38 #include "content/public/browser/android/compositor_client.h"
     39 #include "gpu/command_buffer/client/gles2_interface.h"
     40 #include "third_party/khronos/GLES2/gl2.h"
     41 #include "third_party/khronos/GLES2/gl2ext.h"
     42 #include "third_party/skia/include/core/SkMallocPixelRef.h"
     43 #include "ui/base/android/window_android.h"
     44 #include "ui/gfx/android/device_display_info.h"
     45 #include "ui/gfx/frame_time.h"
     46 #include "ui/gl/android/surface_texture.h"
     47 #include "ui/gl/android/surface_texture_tracker.h"
     48 #include "webkit/common/gpu/context_provider_in_process.h"
     49 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
     50 
     51 namespace {
     52 
     53 const unsigned int kMaxSwapBuffers = 2U;
     54 
     55 // Used to override capabilities_.adjust_deadline_for_parent to false
     56 class OutputSurfaceWithoutParent : public cc::OutputSurface {
     57  public:
     58   OutputSurfaceWithoutParent(const scoped_refptr<
     59       content::ContextProviderCommandBuffer>& context_provider)
     60       : cc::OutputSurface(context_provider) {
     61     capabilities_.adjust_deadline_for_parent = false;
     62   }
     63 
     64   virtual void SwapBuffers(cc::CompositorFrame* frame) OVERRIDE {
     65     content::ContextProviderCommandBuffer* provider_command_buffer =
     66         static_cast<content::ContextProviderCommandBuffer*>(
     67             context_provider_.get());
     68     content::CommandBufferProxyImpl* command_buffer_proxy =
     69         provider_command_buffer->GetCommandBufferProxy();
     70     DCHECK(command_buffer_proxy);
     71     command_buffer_proxy->SetLatencyInfo(frame->metadata.latency_info);
     72 
     73     OutputSurface::SwapBuffers(frame);
     74   }
     75 };
     76 
     77 class SurfaceTextureTrackerImpl : public gfx::SurfaceTextureTracker {
     78  public:
     79   SurfaceTextureTrackerImpl() : next_surface_texture_id_(1) {
     80     thread_checker_.DetachFromThread();
     81   }
     82 
     83   // Overridden from gfx::SurfaceTextureTracker:
     84   virtual scoped_refptr<gfx::SurfaceTexture> AcquireSurfaceTexture(
     85       int primary_id,
     86       int secondary_id) OVERRIDE {
     87     base::AutoLock lock(surface_textures_lock_);
     88     SurfaceTextureMapKey key(primary_id, secondary_id);
     89     SurfaceTextureMap::iterator it = surface_textures_.find(key);
     90     if (it == surface_textures_.end())
     91       return scoped_refptr<gfx::SurfaceTexture>();
     92     scoped_refptr<gfx::SurfaceTexture> surface_texture = it->second;
     93     surface_textures_.erase(it);
     94     return surface_texture;
     95   }
     96 
     97   int AddSurfaceTexture(gfx::SurfaceTexture* surface_texture,
     98                         int child_process_id) {
     99     DCHECK(thread_checker_.CalledOnValidThread());
    100     int surface_texture_id = next_surface_texture_id_++;
    101     if (next_surface_texture_id_ == INT_MAX)
    102       next_surface_texture_id_ = 1;
    103 
    104     base::AutoLock lock(surface_textures_lock_);
    105     SurfaceTextureMapKey key(surface_texture_id, child_process_id);
    106     DCHECK(surface_textures_.find(key) == surface_textures_.end());
    107     surface_textures_[key] = surface_texture;
    108     content::RegisterChildProcessSurfaceTexture(
    109         surface_texture_id,
    110         child_process_id,
    111         surface_texture->j_surface_texture().obj());
    112     return surface_texture_id;
    113   }
    114 
    115   void RemoveAllSurfaceTextures(int child_process_id) {
    116     DCHECK(thread_checker_.CalledOnValidThread());
    117     base::AutoLock lock(surface_textures_lock_);
    118     SurfaceTextureMap::iterator it = surface_textures_.begin();
    119     while (it != surface_textures_.end()) {
    120       if (it->first.second == child_process_id) {
    121         content::UnregisterChildProcessSurfaceTexture(it->first.first,
    122                                                       it->first.second);
    123         surface_textures_.erase(it++);
    124       } else {
    125         ++it;
    126       }
    127     }
    128   }
    129 
    130  private:
    131   typedef std::pair<int, int> SurfaceTextureMapKey;
    132   typedef base::hash_map<SurfaceTextureMapKey,
    133                          scoped_refptr<gfx::SurfaceTexture> >
    134       SurfaceTextureMap;
    135   SurfaceTextureMap surface_textures_;
    136   mutable base::Lock surface_textures_lock_;
    137   int next_surface_texture_id_;
    138   base::ThreadChecker thread_checker_;
    139 };
    140 base::LazyInstance<SurfaceTextureTrackerImpl> g_surface_texture_tracker =
    141     LAZY_INSTANCE_INITIALIZER;
    142 
    143 static bool g_initialized = false;
    144 
    145 } // anonymous namespace
    146 
    147 namespace content {
    148 
    149 // static
    150 Compositor* Compositor::Create(CompositorClient* client,
    151                                gfx::NativeWindow root_window) {
    152   return client ? new CompositorImpl(client, root_window) : NULL;
    153 }
    154 
    155 // static
    156 void Compositor::Initialize() {
    157   DCHECK(!CompositorImpl::IsInitialized());
    158   // SurfaceTextureTracker instance must be set before we create a GPU thread
    159   // that could be using it to initialize GLImage instances.
    160   gfx::SurfaceTextureTracker::InitInstance(g_surface_texture_tracker.Pointer());
    161   g_initialized = true;
    162 }
    163 
    164 // static
    165 bool CompositorImpl::IsInitialized() {
    166   return g_initialized;
    167 }
    168 
    169 // static
    170 int CompositorImpl::CreateSurfaceTexture(int child_process_id) {
    171   // Note: this needs to be 0 as the surface texture implemenation will take
    172   // ownership of the texture and call glDeleteTextures when the GPU service
    173   // attaches the surface texture to a real texture id. glDeleteTextures
    174   // silently ignores 0.
    175   const int kDummyTextureId = 0;
    176   scoped_refptr<gfx::SurfaceTexture> surface_texture =
    177       gfx::SurfaceTexture::Create(kDummyTextureId);
    178   return g_surface_texture_tracker.Pointer()->AddSurfaceTexture(
    179       surface_texture.get(), child_process_id);
    180 }
    181 
    182 // static
    183 void CompositorImpl::DestroyAllSurfaceTextures(int child_process_id) {
    184   g_surface_texture_tracker.Pointer()->RemoveAllSurfaceTextures(
    185       child_process_id);
    186 }
    187 
    188 CompositorImpl::CompositorImpl(CompositorClient* client,
    189                                gfx::NativeWindow root_window)
    190     : root_layer_(cc::Layer::Create()),
    191       has_transparent_background_(false),
    192       device_scale_factor_(1),
    193       window_(NULL),
    194       surface_id_(0),
    195       client_(client),
    196       root_window_(root_window),
    197       did_post_swapbuffers_(false),
    198       ignore_schedule_composite_(false),
    199       needs_composite_(false),
    200       needs_animate_(false),
    201       will_composite_immediately_(false),
    202       composite_on_vsync_trigger_(DO_NOT_COMPOSITE),
    203       pending_swapbuffers_(0U),
    204       weak_factory_(this) {
    205   DCHECK(client);
    206   DCHECK(root_window);
    207   ImageTransportFactoryAndroid::AddObserver(this);
    208   root_window->AttachCompositor(this);
    209 }
    210 
    211 CompositorImpl::~CompositorImpl() {
    212   root_window_->DetachCompositor();
    213   ImageTransportFactoryAndroid::RemoveObserver(this);
    214   // Clean-up any surface references.
    215   SetSurface(NULL);
    216 }
    217 
    218 void CompositorImpl::PostComposite(CompositingTrigger trigger) {
    219   DCHECK(needs_composite_);
    220   DCHECK(trigger == COMPOSITE_IMMEDIATELY || trigger == COMPOSITE_EVENTUALLY);
    221 
    222   if (will_composite_immediately_ ||
    223       (trigger == COMPOSITE_EVENTUALLY && WillComposite())) {
    224     // We will already composite soon enough.
    225     DCHECK(WillComposite());
    226     return;
    227   }
    228 
    229   if (DidCompositeThisFrame()) {
    230     DCHECK(!WillCompositeThisFrame());
    231     if (composite_on_vsync_trigger_ != COMPOSITE_IMMEDIATELY) {
    232       composite_on_vsync_trigger_ = trigger;
    233       root_window_->RequestVSyncUpdate();
    234     }
    235     DCHECK(WillComposite());
    236     return;
    237   }
    238 
    239   base::TimeDelta delay;
    240   if (trigger == COMPOSITE_IMMEDIATELY) {
    241     will_composite_immediately_ = true;
    242     composite_on_vsync_trigger_ = DO_NOT_COMPOSITE;
    243   } else {
    244     DCHECK(!WillComposite());
    245     const base::TimeDelta estimated_composite_time = vsync_period_ / 4;
    246     const base::TimeTicks now = base::TimeTicks::Now();
    247 
    248     if (!last_vsync_.is_null() && (now - last_vsync_) < vsync_period_) {
    249       base::TimeTicks next_composite =
    250           last_vsync_ + vsync_period_ - estimated_composite_time;
    251       if (next_composite < now) {
    252         // It's too late, we will reschedule composite as needed on the next
    253         // vsync.
    254         composite_on_vsync_trigger_ = COMPOSITE_EVENTUALLY;
    255         root_window_->RequestVSyncUpdate();
    256         DCHECK(WillComposite());
    257         return;
    258       }
    259 
    260       delay = next_composite - now;
    261     }
    262   }
    263   TRACE_EVENT2("cc", "CompositorImpl::PostComposite",
    264                "trigger", trigger,
    265                "delay", delay.InMillisecondsF());
    266 
    267   DCHECK(composite_on_vsync_trigger_ == DO_NOT_COMPOSITE);
    268   if (current_composite_task_)
    269     current_composite_task_->Cancel();
    270 
    271   // Unretained because we cancel the task on shutdown.
    272   current_composite_task_.reset(new base::CancelableClosure(
    273       base::Bind(&CompositorImpl::Composite, base::Unretained(this), trigger)));
    274   base::MessageLoop::current()->PostDelayedTask(
    275       FROM_HERE, current_composite_task_->callback(), delay);
    276 }
    277 
    278 void CompositorImpl::Composite(CompositingTrigger trigger) {
    279   BrowserGpuChannelHostFactory* factory =
    280       BrowserGpuChannelHostFactory::instance();
    281   if (!factory->GetGpuChannel() || factory->GetGpuChannel()->IsLost()) {
    282     CauseForGpuLaunch cause =
    283         CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
    284     factory->EstablishGpuChannel(
    285         cause,
    286         base::Bind(&CompositorImpl::OnGpuChannelEstablished,
    287                    weak_factory_.GetWeakPtr()));
    288     return;
    289   }
    290 
    291   DCHECK(host_);
    292   DCHECK(trigger == COMPOSITE_IMMEDIATELY || trigger == COMPOSITE_EVENTUALLY);
    293   DCHECK(needs_composite_);
    294   DCHECK(!DidCompositeThisFrame());
    295 
    296   if (trigger == COMPOSITE_IMMEDIATELY)
    297     will_composite_immediately_ = false;
    298 
    299   DCHECK_LE(pending_swapbuffers_, kMaxSwapBuffers);
    300   if (pending_swapbuffers_ == kMaxSwapBuffers) {
    301     TRACE_EVENT0("compositor", "CompositorImpl_SwapLimit");
    302     return;
    303   }
    304 
    305   // Reset state before Layout+Composite since that might create more
    306   // requests to Composite that we need to respect.
    307   needs_composite_ = false;
    308 
    309   // Only allow compositing once per vsync.
    310   current_composite_task_->Cancel();
    311   DCHECK(DidCompositeThisFrame() && !WillComposite());
    312 
    313   // Ignore ScheduleComposite() from layer tree changes during layout and
    314   // animation updates that will already be reflected in the current frame
    315   // we are about to draw.
    316   ignore_schedule_composite_ = true;
    317   client_->Layout();
    318 
    319   const base::TimeTicks frame_time = gfx::FrameTime::Now();
    320   if (needs_animate_) {
    321     needs_animate_ = false;
    322     root_window_->Animate(frame_time);
    323   }
    324   ignore_schedule_composite_ = false;
    325 
    326   did_post_swapbuffers_ = false;
    327   host_->Composite(frame_time);
    328   if (did_post_swapbuffers_)
    329     pending_swapbuffers_++;
    330 
    331   // Need to track vsync to avoid compositing more than once per frame.
    332   root_window_->RequestVSyncUpdate();
    333 }
    334 
    335 void CompositorImpl::OnGpuChannelEstablished() {
    336   ScheduleComposite();
    337 }
    338 
    339 UIResourceProvider& CompositorImpl::GetUIResourceProvider() {
    340   return ui_resource_provider_;
    341 }
    342 
    343 void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
    344   if (subroot_layer_) {
    345     subroot_layer_->RemoveFromParent();
    346     subroot_layer_ = NULL;
    347   }
    348   if (root_layer) {
    349     subroot_layer_ = root_layer;
    350     root_layer_->AddChild(root_layer);
    351   }
    352 }
    353 
    354 void CompositorImpl::SetWindowSurface(ANativeWindow* window) {
    355   GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
    356 
    357   if (window_) {
    358     tracker->RemoveSurface(surface_id_);
    359     ANativeWindow_release(window_);
    360     window_ = NULL;
    361     surface_id_ = 0;
    362     SetVisible(false);
    363   }
    364 
    365   if (window) {
    366     window_ = window;
    367     ANativeWindow_acquire(window);
    368     surface_id_ = tracker->AddSurfaceForNativeWidget(window);
    369     tracker->SetSurfaceHandle(
    370         surface_id_,
    371         gfx::GLSurfaceHandle(gfx::kNullPluginWindow, gfx::NATIVE_DIRECT));
    372     SetVisible(true);
    373   }
    374 }
    375 
    376 void CompositorImpl::SetSurface(jobject surface) {
    377   JNIEnv* env = base::android::AttachCurrentThread();
    378   base::android::ScopedJavaLocalRef<jobject> j_surface(env, surface);
    379 
    380   // First, cleanup any existing surface references.
    381   if (surface_id_)
    382     content::UnregisterViewSurface(surface_id_);
    383   SetWindowSurface(NULL);
    384 
    385   // Now, set the new surface if we have one.
    386   ANativeWindow* window = NULL;
    387   if (surface) {
    388     // Note: This ensures that any local references used by
    389     // ANativeWindow_fromSurface are released immediately. This is needed as a
    390     // workaround for https://code.google.com/p/android/issues/detail?id=68174
    391     base::android::ScopedJavaLocalFrame scoped_local_reference_frame(env);
    392     window = ANativeWindow_fromSurface(env, surface);
    393   }
    394   if (window) {
    395     SetWindowSurface(window);
    396     ANativeWindow_release(window);
    397     content::RegisterViewSurface(surface_id_, j_surface.obj());
    398   }
    399 }
    400 
    401 void CompositorImpl::SetVisible(bool visible) {
    402   if (!visible) {
    403     if (WillComposite())
    404       CancelComposite();
    405     ui_resource_provider_.SetLayerTreeHost(NULL);
    406     host_.reset();
    407   } else if (!host_) {
    408     DCHECK(!WillComposite());
    409     needs_composite_ = false;
    410     needs_animate_ = false;
    411     pending_swapbuffers_ = 0;
    412     cc::LayerTreeSettings settings;
    413     settings.refresh_rate = 60.0;
    414     settings.impl_side_painting = false;
    415     settings.allow_antialiasing = false;
    416     settings.calculate_top_controls_position = false;
    417     settings.top_controls_height = 0.f;
    418     settings.highp_threshold_min = 2048;
    419 
    420     CommandLine* command_line = CommandLine::ForCurrentProcess();
    421     settings.initial_debug_state.SetRecordRenderingStats(
    422         command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
    423     settings.initial_debug_state.show_fps_counter =
    424         command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
    425 
    426     host_ = cc::LayerTreeHost::CreateSingleThreaded(
    427         this, this, HostSharedBitmapManager::current(), settings);
    428     host_->SetRootLayer(root_layer_);
    429 
    430     host_->SetVisible(true);
    431     host_->SetLayerTreeHostClientReady();
    432     host_->SetViewportSize(size_);
    433     host_->set_has_transparent_background(has_transparent_background_);
    434     host_->SetDeviceScaleFactor(device_scale_factor_);
    435     ui_resource_provider_.SetLayerTreeHost(host_.get());
    436   }
    437 }
    438 
    439 void CompositorImpl::setDeviceScaleFactor(float factor) {
    440   device_scale_factor_ = factor;
    441   if (host_)
    442     host_->SetDeviceScaleFactor(factor);
    443 }
    444 
    445 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
    446   if (size_ == size)
    447     return;
    448 
    449   size_ = size;
    450   if (host_)
    451     host_->SetViewportSize(size);
    452   root_layer_->SetBounds(size);
    453 }
    454 
    455 void CompositorImpl::SetHasTransparentBackground(bool flag) {
    456   has_transparent_background_ = flag;
    457   if (host_)
    458     host_->set_has_transparent_background(flag);
    459 }
    460 
    461 void CompositorImpl::SetNeedsComposite() {
    462   if (!host_.get())
    463     return;
    464   DCHECK(!needs_composite_ || WillComposite());
    465 
    466   needs_composite_ = true;
    467   PostComposite(COMPOSITE_IMMEDIATELY);
    468 }
    469 
    470 static scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
    471 CreateGpuProcessViewContext(
    472     const scoped_refptr<GpuChannelHost>& gpu_channel_host,
    473     const blink::WebGraphicsContext3D::Attributes attributes,
    474     int surface_id) {
    475   DCHECK(gpu_channel_host);
    476 
    477   GURL url("chrome://gpu/Compositor::createContext3D");
    478   static const size_t kBytesPerPixel = 4;
    479   gfx::DeviceDisplayInfo display_info;
    480   size_t full_screen_texture_size_in_bytes =
    481       display_info.GetDisplayHeight() *
    482       display_info.GetDisplayWidth() *
    483       kBytesPerPixel;
    484   WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
    485   limits.command_buffer_size = 64 * 1024;
    486   limits.start_transfer_buffer_size = 64 * 1024;
    487   limits.min_transfer_buffer_size = 64 * 1024;
    488   limits.max_transfer_buffer_size = std::min(
    489       3 * full_screen_texture_size_in_bytes, kDefaultMaxTransferBufferSize);
    490   limits.mapped_memory_reclaim_limit = 2 * 1024 * 1024;
    491   bool lose_context_when_out_of_memory = true;
    492   return make_scoped_ptr(
    493       new WebGraphicsContext3DCommandBufferImpl(surface_id,
    494                                                 url,
    495                                                 gpu_channel_host.get(),
    496                                                 attributes,
    497                                                 lose_context_when_out_of_memory,
    498                                                 limits,
    499                                                 NULL));
    500 }
    501 
    502 void CompositorImpl::Layout() {
    503   // TODO: If we get this callback from the SingleThreadProxy, we need
    504   // to stop calling it ourselves in CompositorImpl::Composite().
    505   NOTREACHED();
    506   client_->Layout();
    507 }
    508 
    509 scoped_ptr<cc::OutputSurface> CompositorImpl::CreateOutputSurface(
    510     bool fallback) {
    511   blink::WebGraphicsContext3D::Attributes attrs;
    512   attrs.shareResources = true;
    513   attrs.noAutomaticFlushes = true;
    514   pending_swapbuffers_ = 0;
    515 
    516   DCHECK(window_);
    517   DCHECK(surface_id_);
    518 
    519   scoped_refptr<ContextProviderCommandBuffer> context_provider;
    520   BrowserGpuChannelHostFactory* factory =
    521       BrowserGpuChannelHostFactory::instance();
    522   scoped_refptr<GpuChannelHost> gpu_channel_host = factory->GetGpuChannel();
    523   if (gpu_channel_host && !gpu_channel_host->IsLost()) {
    524     context_provider = ContextProviderCommandBuffer::Create(
    525         CreateGpuProcessViewContext(gpu_channel_host, attrs, surface_id_),
    526         "BrowserCompositor");
    527   }
    528   if (!context_provider.get()) {
    529     LOG(ERROR) << "Failed to create 3D context for compositor.";
    530     return scoped_ptr<cc::OutputSurface>();
    531   }
    532 
    533   return scoped_ptr<cc::OutputSurface>(
    534       new OutputSurfaceWithoutParent(context_provider));
    535 }
    536 
    537 void CompositorImpl::OnLostResources() {
    538   client_->DidLoseResources();
    539   ui_resource_provider_.UIResourcesAreInvalid();
    540 }
    541 
    542 void CompositorImpl::ScheduleComposite() {
    543   DCHECK(!needs_composite_ || WillComposite());
    544   if (ignore_schedule_composite_)
    545     return;
    546 
    547   needs_composite_ = true;
    548   // We currently expect layer tree invalidations at most once per frame
    549   // during normal operation and therefore try to composite immediately
    550   // to minimize latency.
    551   PostComposite(COMPOSITE_IMMEDIATELY);
    552 }
    553 
    554 void CompositorImpl::ScheduleAnimation() {
    555   DCHECK(!needs_animate_ || needs_composite_);
    556   DCHECK(!needs_composite_ || WillComposite());
    557   needs_animate_ = true;
    558 
    559   if (needs_composite_)
    560     return;
    561 
    562   TRACE_EVENT0("cc", "CompositorImpl::ScheduleAnimation");
    563   needs_composite_ = true;
    564   PostComposite(COMPOSITE_EVENTUALLY);
    565 }
    566 
    567 void CompositorImpl::DidPostSwapBuffers() {
    568   TRACE_EVENT0("compositor", "CompositorImpl::DidPostSwapBuffers");
    569   did_post_swapbuffers_ = true;
    570 }
    571 
    572 void CompositorImpl::DidCompleteSwapBuffers() {
    573   TRACE_EVENT0("compositor", "CompositorImpl::DidCompleteSwapBuffers");
    574   DCHECK_GT(pending_swapbuffers_, 0U);
    575   if (pending_swapbuffers_-- == kMaxSwapBuffers && needs_composite_)
    576     PostComposite(COMPOSITE_IMMEDIATELY);
    577   client_->OnSwapBuffersCompleted(pending_swapbuffers_);
    578 }
    579 
    580 void CompositorImpl::DidAbortSwapBuffers() {
    581   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
    582   // This really gets called only once from
    583   // SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() when the
    584   // context was lost.
    585   client_->OnSwapBuffersCompleted(0);
    586 }
    587 
    588 void CompositorImpl::DidCommit() {
    589   root_window_->OnCompositingDidCommit();
    590 }
    591 
    592 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
    593   root_layer_->AddChild(layer);
    594 }
    595 
    596 void CompositorImpl::RequestCopyOfOutputOnRootLayer(
    597     scoped_ptr<cc::CopyOutputRequest> request) {
    598   root_layer_->RequestCopyOfOutput(request.Pass());
    599 }
    600 
    601 void CompositorImpl::OnVSync(base::TimeTicks frame_time,
    602                              base::TimeDelta vsync_period) {
    603   vsync_period_ = vsync_period;
    604   last_vsync_ = frame_time;
    605 
    606   if (WillCompositeThisFrame()) {
    607     // We somehow missed the last vsync interval, so reschedule for deadline.
    608     // We cannot schedule immediately, or will get us out-of-phase with new
    609     // renderer frames.
    610     CancelComposite();
    611     composite_on_vsync_trigger_ = COMPOSITE_EVENTUALLY;
    612   } else {
    613     current_composite_task_.reset();
    614   }
    615 
    616   DCHECK(!DidCompositeThisFrame() && !WillCompositeThisFrame());
    617   if (composite_on_vsync_trigger_ != DO_NOT_COMPOSITE) {
    618     CompositingTrigger trigger = composite_on_vsync_trigger_;
    619     composite_on_vsync_trigger_ = DO_NOT_COMPOSITE;
    620     PostComposite(trigger);
    621   }
    622 }
    623 
    624 void CompositorImpl::SetNeedsAnimate() {
    625   if (!host_)
    626     return;
    627 
    628   host_->SetNeedsAnimate();
    629 }
    630 
    631 }  // namespace content
    632