src/ui/compositor/compositor.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 "ui/compositor/compositor.h"
   6
   7 #include <algorithm>
   8 #include <deque>
   9
  10 #include "base/bind.h"
  11 #include "base/command_line.h"
  12 #include "base/debug/trace_event.h"
  13 #include "base/memory/singleton.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/metrics/histogram.h"
  16 #include "base/run_loop.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/sys_info.h"
  19 #include "base/threading/thread.h"
  20 #include "base/threading/thread_restrictions.h"
  21 #include "cc/base/latency_info_swap_promise.h"
  22 #include "cc/base/switches.h"
  23 #include "cc/input/input_handler.h"
  24 #include "cc/layers/layer.h"
  25 #include "cc/output/context_provider.h"
  26 #include "cc/trees/layer_tree_host.h"
  27 #include "third_party/skia/include/core/SkBitmap.h"
  28 #include "ui/compositor/compositor_observer.h"
  29 #include "ui/compositor/compositor_switches.h"
  30 #include "ui/compositor/compositor_vsync_manager.h"
  31 #include "ui/compositor/dip_util.h"
  32 #include "ui/compositor/layer.h"
  33 #include "ui/gfx/frame_time.h"
  34 #include "ui/gl/gl_context.h"
  35 #include "ui/gl/gl_switches.h"
  36
  37 namespace {
  38
  39 const double kDefaultRefreshRate = 60.0;
  40 const double kTestRefreshRate = 200.0;
  41
  42 enum SwapType {
  43   DRAW_SWAP,
  44 };
  45
  46 bool g_compositor_initialized = false;
  47 base::Thread* g_compositor_thread = NULL;
  48
  49 ui::ContextFactory* g_context_factory = NULL;
  50
  51 const int kCompositorLockTimeoutMs = 67;
  52
  53 class PendingSwap {
  54  public:
  55   PendingSwap(SwapType type, ui::PostedSwapQueue* posted_swaps);
  56   ~PendingSwap();
  57
  58   SwapType type() const { return type_; }
  59   bool posted() const { return posted_; }
  60
  61  private:
  62   friend class ui::PostedSwapQueue;
  63
  64   SwapType type_;
  65   bool posted_;
  66   ui::PostedSwapQueue* posted_swaps_;
  67
  68   DISALLOW_COPY_AND_ASSIGN(PendingSwap);
  69 };
  70
  71 }  // namespace
  72
  73 namespace ui {
  74
  75 // static
  76 ContextFactory* ContextFactory::GetInstance() {
  77   DCHECK(g_context_factory);
  78   return g_context_factory;
  79 }
  80
  81 // static
  82 void ContextFactory::SetInstance(ContextFactory* instance) {
  83   g_context_factory = instance;
  84 }
  85
  86 Texture::Texture(bool flipped, const gfx::Size& size, float device_scale_factor)
  87     : size_(size),
  88       flipped_(flipped),
  89       device_scale_factor_(device_scale_factor) {
  90 }
  91
  92 Texture::~Texture() {
  93 }
  94
  95 gpu::Mailbox Texture::Produce() {
  96   return gpu::Mailbox();
  97 }
  98
  99 CompositorLock::CompositorLock(Compositor* compositor)
 100     : compositor_(compositor) {
 101   base::MessageLoop::current()->PostDelayedTask(
 102       FROM_HERE,
 103       base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
 104       base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
 105 }
 106
 107 CompositorLock::~CompositorLock() {
 108   CancelLock();
 109 }
 110
 111 void CompositorLock::CancelLock() {
 112   if (!compositor_)
 113     return;
 114   compositor_->UnlockCompositor();
 115   compositor_ = NULL;
 116 }
 117
 118 class PostedSwapQueue {
 119  public:
 120   PostedSwapQueue() : pending_swap_(NULL) {
 121   }
 122
 123   ~PostedSwapQueue() {
 124     DCHECK(!pending_swap_);
 125   }
 126
 127   SwapType NextPostedSwap() const {
 128     return queue_.front();
 129   }
 130
 131   bool AreSwapsPosted() const {
 132     return !queue_.empty();
 133   }
 134
 135   int NumSwapsPosted(SwapType type) const {
 136     int count = 0;
 137     for (std::deque<SwapType>::const_iterator it = queue_.begin();
 138          it != queue_.end(); ++it) {
 139       if (*it == type)
 140         count++;
 141     }
 142     return count;
 143   }
 144
 145   void PostSwap() {
 146     DCHECK(pending_swap_);
 147     queue_.push_back(pending_swap_->type());
 148     pending_swap_->posted_ = true;
 149   }
 150
 151   void EndSwap() {
 152     queue_.pop_front();
 153   }
 154
 155  private:
 156   friend class ::PendingSwap;
 157
 158   PendingSwap* pending_swap_;
 159   std::deque<SwapType> queue_;
 160
 161   DISALLOW_COPY_AND_ASSIGN(PostedSwapQueue);
 162 };
 163
 164 }  // namespace ui
 165
 166 namespace {
 167
 168 PendingSwap::PendingSwap(SwapType type, ui::PostedSwapQueue* posted_swaps)
 169     : type_(type), posted_(false), posted_swaps_(posted_swaps) {
 170   // Only one pending swap in flight.
 171   DCHECK_EQ(static_cast<PendingSwap*>(NULL), posted_swaps_->pending_swap_);
 172   posted_swaps_->pending_swap_ = this;
 173 }
 174
 175 PendingSwap::~PendingSwap() {
 176   DCHECK_EQ(this, posted_swaps_->pending_swap_);
 177   posted_swaps_->pending_swap_ = NULL;
 178 }
 179
 180 }  // namespace
 181
 182 namespace ui {
 183
 184 Compositor::Compositor(gfx::AcceleratedWidget widget)
 185     : root_layer_(NULL),
 186       widget_(widget),
 187       vsync_manager_(new CompositorVSyncManager()),
 188       posted_swaps_(new PostedSwapQueue()),
 189       device_scale_factor_(0.0f),
 190       last_started_frame_(0),
 191       last_ended_frame_(0),
 192       next_draw_is_resize_(false),
 193       disable_schedule_composite_(false),
 194       compositor_lock_(NULL),
 195       defer_draw_scheduling_(false),
 196       waiting_on_compositing_end_(false),
 197       draw_on_compositing_end_(false),
 198       schedule_draw_factory_(this) {
 199   DCHECK(g_compositor_initialized)
 200       << "Compositor::Initialize must be called before creating a Compositor.";
 201
 202   root_web_layer_ = cc::Layer::Create();
 203   root_web_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 204
 205   CommandLine* command_line = CommandLine::ForCurrentProcess();
 206
 207   cc::LayerTreeSettings settings;
 208   settings.refresh_rate =
 209       ContextFactory::GetInstance()->DoesCreateTestContexts()
 210       ? kTestRefreshRate
 211       : kDefaultRefreshRate;
 212   settings.deadline_scheduling_enabled =
 213       switches::IsUIDeadlineSchedulingEnabled();
 214   settings.partial_swap_enabled =
 215       !command_line->HasSwitch(cc::switches::kUIDisablePartialSwap);
 216   settings.per_tile_painting_enabled =
 217       command_line->HasSwitch(cc::switches::kUIEnablePerTilePainting);
 218
 219   // These flags should be mirrored by renderer versions in content/renderer/.
 220   settings.initial_debug_state.show_debug_borders =
 221       command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders);
 222   settings.initial_debug_state.show_fps_counter =
 223       command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
 224   settings.initial_debug_state.show_layer_animation_bounds_rects =
 225       command_line->HasSwitch(cc::switches::kUIShowLayerAnimationBounds);
 226   settings.initial_debug_state.show_paint_rects =
 227       command_line->HasSwitch(switches::kUIShowPaintRects);
 228   settings.initial_debug_state.show_property_changed_rects =
 229       command_line->HasSwitch(cc::switches::kUIShowPropertyChangedRects);
 230   settings.initial_debug_state.show_surface_damage_rects =
 231       command_line->HasSwitch(cc::switches::kUIShowSurfaceDamageRects);
 232   settings.initial_debug_state.show_screen_space_rects =
 233       command_line->HasSwitch(cc::switches::kUIShowScreenSpaceRects);
 234   settings.initial_debug_state.show_replica_screen_space_rects =
 235       command_line->HasSwitch(cc::switches::kUIShowReplicaScreenSpaceRects);
 236   settings.initial_debug_state.show_occluding_rects =
 237       command_line->HasSwitch(cc::switches::kUIShowOccludingRects);
 238   settings.initial_debug_state.show_non_occluding_rects =
 239       command_line->HasSwitch(cc::switches::kUIShowNonOccludingRects);
 240
 241   settings.initial_debug_state.SetRecordRenderingStats(
 242       command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
 243
 244   base::TimeTicks before_create = base::TimeTicks::Now();
 245   if (!!g_compositor_thread) {
 246     host_ = cc::LayerTreeHost::CreateThreaded(
 247         this, NULL, settings, g_compositor_thread->message_loop_proxy());
 248   } else {
 249     host_ = cc::LayerTreeHost::CreateSingleThreaded(this, this, NULL, settings);
 250   }
 251   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
 252                       base::TimeTicks::Now() - before_create);
 253   host_->SetRootLayer(root_web_layer_);
 254   host_->SetLayerTreeHostClientReady();
 255 }
 256
 257 Compositor::~Compositor() {
 258   TRACE_EVENT0("shutdown", "Compositor::destructor");
 259
 260   DCHECK(g_compositor_initialized);
 261
 262   CancelCompositorLock();
 263   DCHECK(!compositor_lock_);
 264
 265   if (root_layer_)
 266     root_layer_->SetCompositor(NULL);
 267
 268   // Stop all outstanding draws before telling the ContextFactory to tear
 269   // down any contexts that the |host_| may rely upon.
 270   host_.reset();
 271
 272   ContextFactory::GetInstance()->RemoveCompositor(this);
 273 }
 274
 275 // static
 276 void Compositor::Initialize() {
 277 #if defined(OS_CHROMEOS)
 278   bool use_thread = !CommandLine::ForCurrentProcess()->HasSwitch(
 279       switches::kUIDisableThreadedCompositing);
 280 #else
 281   bool use_thread = false;
 282 #endif
 283   if (use_thread) {
 284     g_compositor_thread = new base::Thread("Browser Compositor");
 285     g_compositor_thread->Start();
 286   }
 287
 288   DCHECK(!g_compositor_initialized) << "Compositor initialized twice.";
 289   g_compositor_initialized = true;
 290 }
 291
 292 // static
 293 bool Compositor::WasInitializedWithThread() {
 294   DCHECK(g_compositor_initialized);
 295   return !!g_compositor_thread;
 296 }
 297
 298 // static
 299 scoped_refptr<base::MessageLoopProxy> Compositor::GetCompositorMessageLoop() {
 300   scoped_refptr<base::MessageLoopProxy> proxy;
 301   if (g_compositor_thread)
 302     proxy = g_compositor_thread->message_loop_proxy();
 303   return proxy;
 304 }
 305
 306 // static
 307 void Compositor::Terminate() {
 308   if (g_compositor_thread) {
 309     g_compositor_thread->Stop();
 310     delete g_compositor_thread;
 311     g_compositor_thread = NULL;
 312   }
 313
 314   DCHECK(g_compositor_initialized) << "Compositor::Initialize() didn't happen.";
 315   g_compositor_initialized = false;
 316 }
 317
 318 void Compositor::ScheduleDraw() {
 319   if (g_compositor_thread) {
 320     host_->Composite(gfx::FrameTime::Now());
 321   } else if (!defer_draw_scheduling_) {
 322     defer_draw_scheduling_ = true;
 323     base::MessageLoop::current()->PostTask(
 324         FROM_HERE,
 325         base::Bind(&Compositor::Draw, schedule_draw_factory_.GetWeakPtr()));
 326   }
 327 }
 328
 329 void Compositor::SetRootLayer(Layer* root_layer) {
 330   if (root_layer_ == root_layer)
 331     return;
 332   if (root_layer_)
 333     root_layer_->SetCompositor(NULL);
 334   root_layer_ = root_layer;
 335   if (root_layer_ && !root_layer_->GetCompositor())
 336     root_layer_->SetCompositor(this);
 337   root_web_layer_->RemoveAllChildren();
 338   if (root_layer_)
 339     root_web_layer_->AddChild(root_layer_->cc_layer());
 340 }
 341
 342 void Compositor::SetHostHasTransparentBackground(
 343     bool host_has_transparent_background) {
 344   host_->set_has_transparent_background(host_has_transparent_background);
 345 }
 346
 347 void Compositor::Draw() {
 348   DCHECK(!g_compositor_thread);
 349
 350   defer_draw_scheduling_ = false;
 351   if (waiting_on_compositing_end_) {
 352     draw_on_compositing_end_ = true;
 353     return;
 354   }
 355   waiting_on_compositing_end_ = true;
 356
 357   TRACE_EVENT_ASYNC_BEGIN0("ui", "Compositor::Draw", last_started_frame_ + 1);
 358
 359   if (!root_layer_)
 360     return;
 361
 362   last_started_frame_++;
 363   PendingSwap pending_swap(DRAW_SWAP, posted_swaps_.get());
 364   if (!IsLocked()) {
 365     // TODO(nduca): Temporary while compositor calls
 366     // compositeImmediately() directly.
 367     Layout();
 368     host_->Composite(gfx::FrameTime::Now());
 369
 370 #if defined(OS_WIN)
 371     // While we resize, we are usually a few frames behind. By blocking
 372     // the UI thread here we minize the area that is mis-painted, specially
 373     // in the non-client area. See RenderWidgetHostViewAura::SetBounds for
 374     // more details and bug 177115.
 375     if (next_draw_is_resize_ && (last_ended_frame_ > 1)) {
 376       next_draw_is_resize_ = false;
 377       host_->FinishAllRendering();
 378     }
 379 #endif
 380
 381   }
 382   if (!pending_swap.posted())
 383     NotifyEnd();
 384 }
 385
 386 void Compositor::ScheduleFullRedraw() {
 387   host_->SetNeedsRedraw();
 388 }
 389
 390 void Compositor::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
 391   host_->SetNeedsRedrawRect(damage_rect);
 392 }
 393
 394 void Compositor::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
 395   scoped_ptr<cc::SwapPromise> swap_promise(
 396       new cc::LatencyInfoSwapPromise(latency_info));
 397   host_->QueueSwapPromise(swap_promise.Pass());
 398 }
 399
 400 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
 401   DCHECK_GT(scale, 0);
 402   if (!size_in_pixel.IsEmpty()) {
 403     size_ = size_in_pixel;
 404     host_->SetViewportSize(size_in_pixel);
 405     root_web_layer_->SetBounds(size_in_pixel);
 406
 407     next_draw_is_resize_ = true;
 408   }
 409   if (device_scale_factor_ != scale) {
 410     device_scale_factor_ = scale;
 411     if (root_layer_)
 412       root_layer_->OnDeviceScaleFactorChanged(scale);
 413   }
 414 }
 415
 416 void Compositor::SetBackgroundColor(SkColor color) {
 417   host_->set_background_color(color);
 418   ScheduleDraw();
 419 }
 420
 421 scoped_refptr<CompositorVSyncManager> Compositor::vsync_manager() const {
 422   return vsync_manager_;
 423 }
 424
 425 void Compositor::AddObserver(CompositorObserver* observer) {
 426   observer_list_.AddObserver(observer);
 427 }
 428
 429 void Compositor::RemoveObserver(CompositorObserver* observer) {
 430   observer_list_.RemoveObserver(observer);
 431 }
 432
 433 bool Compositor::HasObserver(CompositorObserver* observer) {
 434   return observer_list_.HasObserver(observer);
 435 }
 436
 437 void Compositor::Layout() {
 438   // We're sending damage that will be addressed during this composite
 439   // cycle, so we don't need to schedule another composite to address it.
 440   disable_schedule_composite_ = true;
 441   if (root_layer_)
 442     root_layer_->SendDamagedRects();
 443   disable_schedule_composite_ = false;
 444 }
 445
 446 scoped_ptr<cc::OutputSurface> Compositor::CreateOutputSurface(bool fallback) {
 447   return ContextFactory::GetInstance()->CreateOutputSurface(this, fallback);
 448 }
 449
 450 void Compositor::DidCommit() {
 451   DCHECK(!IsLocked());
 452   FOR_EACH_OBSERVER(CompositorObserver,
 453                     observer_list_,
 454                     OnCompositingDidCommit(this));
 455 }
 456
 457 void Compositor::DidCommitAndDrawFrame() {
 458   base::TimeTicks start_time = gfx::FrameTime::Now();
 459   FOR_EACH_OBSERVER(CompositorObserver,
 460                     observer_list_,
 461                     OnCompositingStarted(this, start_time));
 462 }
 463
 464 void Compositor::DidCompleteSwapBuffers() {
 465   if (g_compositor_thread) {
 466     NotifyEnd();
 467   } else {
 468     DCHECK(posted_swaps_->AreSwapsPosted());
 469     DCHECK_GE(1, posted_swaps_->NumSwapsPosted(DRAW_SWAP));
 470     if (posted_swaps_->NextPostedSwap() == DRAW_SWAP)
 471       NotifyEnd();
 472     posted_swaps_->EndSwap();
 473   }
 474 }
 475
 476 scoped_refptr<cc::ContextProvider> Compositor::OffscreenContextProvider() {
 477   return ContextFactory::GetInstance()->OffscreenCompositorContextProvider();
 478 }
 479
 480 void Compositor::ScheduleComposite() {
 481   if (!disable_schedule_composite_)
 482     ScheduleDraw();
 483 }
 484
 485 void Compositor::ScheduleAnimation() {
 486   ScheduleComposite();
 487 }
 488
 489 void Compositor::DidPostSwapBuffers() {
 490   DCHECK(!g_compositor_thread);
 491   posted_swaps_->PostSwap();
 492 }
 493
 494 void Compositor::DidAbortSwapBuffers() {
 495   if (!g_compositor_thread) {
 496     DCHECK_GE(1, posted_swaps_->NumSwapsPosted(DRAW_SWAP));
 497
 498     // We've just lost the context, so unwind all posted_swaps.
 499     while (posted_swaps_->AreSwapsPosted()) {
 500       if (posted_swaps_->NextPostedSwap() == DRAW_SWAP)
 501         NotifyEnd();
 502       posted_swaps_->EndSwap();
 503     }
 504   }
 505
 506   FOR_EACH_OBSERVER(CompositorObserver,
 507                     observer_list_,
 508                     OnCompositingAborted(this));
 509 }
 510
 511 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
 512   return host_->debug_state();
 513 }
 514
 515 void Compositor::SetLayerTreeDebugState(
 516     const cc::LayerTreeDebugState& debug_state) {
 517   host_->SetDebugState(debug_state);
 518 }
 519
 520 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
 521   if (!compositor_lock_) {
 522     compositor_lock_ = new CompositorLock(this);
 523     if (g_compositor_thread)
 524       host_->SetDeferCommits(true);
 525     FOR_EACH_OBSERVER(CompositorObserver,
 526                       observer_list_,
 527                       OnCompositingLockStateChanged(this));
 528   }
 529   return compositor_lock_;
 530 }
 531
 532 void Compositor::UnlockCompositor() {
 533   DCHECK(compositor_lock_);
 534   compositor_lock_ = NULL;
 535   if (g_compositor_thread)
 536     host_->SetDeferCommits(false);
 537   FOR_EACH_OBSERVER(CompositorObserver,
 538                     observer_list_,
 539                     OnCompositingLockStateChanged(this));
 540 }
 541
 542 void Compositor::CancelCompositorLock() {
 543   if (compositor_lock_)
 544     compositor_lock_->CancelLock();
 545 }
 546
 547 void Compositor::NotifyEnd() {
 548   last_ended_frame_++;
 549   TRACE_EVENT_ASYNC_END0("ui", "Compositor::Draw", last_ended_frame_);
 550   waiting_on_compositing_end_ = false;
 551   if (draw_on_compositing_end_) {
 552     draw_on_compositing_end_ = false;
 553
 554     // Call ScheduleDraw() instead of Draw() in order to allow other
 555     // CompositorObservers to be notified before starting another
 556     // draw cycle.
 557     ScheduleDraw();
 558   }
 559   FOR_EACH_OBSERVER(CompositorObserver,
 560                     observer_list_,
 561                     OnCompositingEnded(this));
 562 }
 563
 564 }  // namespace ui