src/content/browser/renderer_host/compositor_impl_android.cc

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