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/message_loop/message_loop.h"
  14 #include "base/metrics/histogram.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/sys_info.h"
  17 #include "cc/base/latency_info_swap_promise.h"
  18 #include "cc/base/switches.h"
  19 #include "cc/input/input_handler.h"
  20 #include "cc/layers/layer.h"
  21 #include "cc/output/context_provider.h"
  22 #include "cc/trees/layer_tree_host.h"
  23 #include "third_party/skia/include/core/SkBitmap.h"
  24 #include "ui/compositor/compositor_observer.h"
  25 #include "ui/compositor/compositor_switches.h"
  26 #include "ui/compositor/compositor_vsync_manager.h"
  27 #include "ui/compositor/dip_util.h"
  28 #include "ui/compositor/layer.h"
  29 #include "ui/compositor/layer_animator_collection.h"
  30 #include "ui/gfx/frame_time.h"
  31 #include "ui/gl/gl_context.h"
  32 #include "ui/gl/gl_switches.h"
  33
  34 namespace {
  35
  36 const double kDefaultRefreshRate = 60.0;
  37 const double kTestRefreshRate = 200.0;
  38
  39 const int kCompositorLockTimeoutMs = 67;
  40
  41 }  // namespace
  42
  43 namespace ui {
  44
  45 CompositorLock::CompositorLock(Compositor* compositor)
  46     : compositor_(compositor) {
  47   base::MessageLoop::current()->PostDelayedTask(
  48       FROM_HERE,
  49       base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
  50       base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
  51 }
  52
  53 CompositorLock::~CompositorLock() {
  54   CancelLock();
  55 }
  56
  57 void CompositorLock::CancelLock() {
  58   if (!compositor_)
  59     return;
  60   compositor_->UnlockCompositor();
  61   compositor_ = NULL;
  62 }
  63
  64 }  // namespace ui
  65
  66 namespace {
  67
  68 }  // namespace
  69
  70 namespace ui {
  71
  72 Compositor::Compositor(gfx::AcceleratedWidget widget,
  73                        ui::ContextFactory* context_factory)
  74     : context_factory_(context_factory),
  75       root_layer_(NULL),
  76       widget_(widget),
  77       compositor_thread_loop_(context_factory->GetCompositorMessageLoop()),
  78       vsync_manager_(new CompositorVSyncManager()),
  79       device_scale_factor_(0.0f),
  80       last_started_frame_(0),
  81       last_ended_frame_(0),
  82       disable_schedule_composite_(false),
  83       compositor_lock_(NULL),
  84       defer_draw_scheduling_(false),
  85       waiting_on_compositing_end_(false),
  86       draw_on_compositing_end_(false),
  87       swap_state_(SWAP_NONE),
  88       layer_animator_collection_(this),
  89       schedule_draw_factory_(this) {
  90   root_web_layer_ = cc::Layer::Create();
  91
  92   CommandLine* command_line = CommandLine::ForCurrentProcess();
  93
  94   cc::LayerTreeSettings settings;
  95   settings.refresh_rate =
  96       context_factory_->DoesCreateTestContexts()
  97       ? kTestRefreshRate
  98       : kDefaultRefreshRate;
  99   settings.main_frame_before_draw_enabled = false;
 100   settings.main_frame_before_activation_enabled = false;
 101   settings.throttle_frame_production =
 102       !command_line->HasSwitch(switches::kDisableGpuVsync);
 103 #if !defined(OS_MACOSX)
 104   settings.partial_swap_enabled =
 105       !command_line->HasSwitch(cc::switches::kUIDisablePartialSwap);
 106 #endif
 107 #if defined(OS_CHROMEOS)
 108   settings.per_tile_painting_enabled = true;
 109 #endif
 110
 111   // These flags should be mirrored by renderer versions in content/renderer/.
 112   settings.initial_debug_state.show_debug_borders =
 113       command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders);
 114   settings.initial_debug_state.show_fps_counter =
 115       command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
 116   settings.initial_debug_state.show_layer_animation_bounds_rects =
 117       command_line->HasSwitch(cc::switches::kUIShowLayerAnimationBounds);
 118   settings.initial_debug_state.show_paint_rects =
 119       command_line->HasSwitch(switches::kUIShowPaintRects);
 120   settings.initial_debug_state.show_property_changed_rects =
 121       command_line->HasSwitch(cc::switches::kUIShowPropertyChangedRects);
 122   settings.initial_debug_state.show_surface_damage_rects =
 123       command_line->HasSwitch(cc::switches::kUIShowSurfaceDamageRects);
 124   settings.initial_debug_state.show_screen_space_rects =
 125       command_line->HasSwitch(cc::switches::kUIShowScreenSpaceRects);
 126   settings.initial_debug_state.show_replica_screen_space_rects =
 127       command_line->HasSwitch(cc::switches::kUIShowReplicaScreenSpaceRects);
 128   settings.initial_debug_state.show_occluding_rects =
 129       command_line->HasSwitch(cc::switches::kUIShowOccludingRects);
 130   settings.initial_debug_state.show_non_occluding_rects =
 131       command_line->HasSwitch(cc::switches::kUIShowNonOccludingRects);
 132
 133   settings.initial_debug_state.SetRecordRenderingStats(
 134       command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
 135
 136   settings.impl_side_painting = IsUIImplSidePaintingEnabled();
 137   settings.use_zero_copy = IsUIZeroCopyEnabled();
 138
 139   base::TimeTicks before_create = base::TimeTicks::Now();
 140   if (compositor_thread_loop_) {
 141     host_ = cc::LayerTreeHost::CreateThreaded(
 142         this,
 143         context_factory_->GetSharedBitmapManager(),
 144         settings,
 145         compositor_thread_loop_);
 146   } else {
 147     host_ = cc::LayerTreeHost::CreateSingleThreaded(
 148         this, this, context_factory_->GetSharedBitmapManager(), settings);
 149   }
 150   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
 151                       base::TimeTicks::Now() - before_create);
 152   host_->SetRootLayer(root_web_layer_);
 153   host_->SetLayerTreeHostClientReady();
 154 }
 155
 156 Compositor::~Compositor() {
 157   TRACE_EVENT0("shutdown", "Compositor::destructor");
 158
 159   CancelCompositorLock();
 160   DCHECK(!compositor_lock_);
 161
 162   if (root_layer_)
 163     root_layer_->SetCompositor(NULL);
 164
 165   // Stop all outstanding draws before telling the ContextFactory to tear
 166   // down any contexts that the |host_| may rely upon.
 167   host_.reset();
 168
 169   context_factory_->RemoveCompositor(this);
 170 }
 171
 172 void Compositor::ScheduleDraw() {
 173   if (compositor_thread_loop_) {
 174     host_->SetNeedsCommit();
 175   } else if (!defer_draw_scheduling_) {
 176     defer_draw_scheduling_ = true;
 177     base::MessageLoop::current()->PostTask(
 178         FROM_HERE,
 179         base::Bind(&Compositor::Draw, schedule_draw_factory_.GetWeakPtr()));
 180   }
 181 }
 182
 183 void Compositor::SetRootLayer(Layer* root_layer) {
 184   if (root_layer_ == root_layer)
 185     return;
 186   if (root_layer_)
 187     root_layer_->SetCompositor(NULL);
 188   root_layer_ = root_layer;
 189   if (root_layer_ && !root_layer_->GetCompositor())
 190     root_layer_->SetCompositor(this);
 191   root_web_layer_->RemoveAllChildren();
 192   if (root_layer_)
 193     root_web_layer_->AddChild(root_layer_->cc_layer());
 194 }
 195
 196 void Compositor::SetHostHasTransparentBackground(
 197     bool host_has_transparent_background) {
 198   host_->set_has_transparent_background(host_has_transparent_background);
 199 }
 200
 201 void Compositor::Draw() {
 202   DCHECK(!compositor_thread_loop_);
 203
 204   defer_draw_scheduling_ = false;
 205   if (waiting_on_compositing_end_) {
 206     draw_on_compositing_end_ = true;
 207     return;
 208   }
 209   if (!root_layer_)
 210     return;
 211
 212   TRACE_EVENT_ASYNC_BEGIN0("ui", "Compositor::Draw", last_started_frame_ + 1);
 213
 214   DCHECK_NE(swap_state_, SWAP_POSTED);
 215   swap_state_ = SWAP_NONE;
 216
 217   waiting_on_compositing_end_ = true;
 218   last_started_frame_++;
 219   if (!IsLocked()) {
 220     // TODO(nduca): Temporary while compositor calls
 221     // compositeImmediately() directly.
 222     base::TimeTicks now = gfx::FrameTime::Now();
 223     Animate(now);
 224     Layout();
 225     host_->Composite(now);
 226   }
 227   if (swap_state_ == SWAP_NONE)
 228     NotifyEnd();
 229 }
 230
 231 void Compositor::ScheduleFullRedraw() {
 232   host_->SetNeedsRedraw();
 233 }
 234
 235 void Compositor::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
 236   host_->SetNeedsRedrawRect(damage_rect);
 237 }
 238
 239 void Compositor::FinishAllRendering() {
 240   host_->FinishAllRendering();
 241 }
 242
 243 void Compositor::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
 244   scoped_ptr<cc::SwapPromise> swap_promise(
 245       new cc::LatencyInfoSwapPromise(latency_info));
 246   host_->QueueSwapPromise(swap_promise.Pass());
 247 }
 248
 249 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
 250   DCHECK_GT(scale, 0);
 251   if (!size_in_pixel.IsEmpty()) {
 252     size_ = size_in_pixel;
 253     host_->SetViewportSize(size_in_pixel);
 254     root_web_layer_->SetBounds(size_in_pixel);
 255   }
 256   if (device_scale_factor_ != scale) {
 257     device_scale_factor_ = scale;
 258     host_->SetDeviceScaleFactor(scale);
 259     if (root_layer_)
 260       root_layer_->OnDeviceScaleFactorChanged(scale);
 261   }
 262 }
 263
 264 void Compositor::SetBackgroundColor(SkColor color) {
 265   host_->set_background_color(color);
 266   ScheduleDraw();
 267 }
 268
 269 scoped_refptr<CompositorVSyncManager> Compositor::vsync_manager() const {
 270   return vsync_manager_;
 271 }
 272
 273 void Compositor::AddObserver(CompositorObserver* observer) {
 274   observer_list_.AddObserver(observer);
 275 }
 276
 277 void Compositor::RemoveObserver(CompositorObserver* observer) {
 278   observer_list_.RemoveObserver(observer);
 279 }
 280
 281 bool Compositor::HasObserver(CompositorObserver* observer) {
 282   return observer_list_.HasObserver(observer);
 283 }
 284
 285 void Compositor::Animate(base::TimeTicks frame_begin_time) {
 286   layer_animator_collection_.Progress(frame_begin_time);
 287   if (layer_animator_collection_.HasActiveAnimators())
 288     host_->SetNeedsAnimate();
 289 }
 290
 291 void Compositor::Layout() {
 292   // We're sending damage that will be addressed during this composite
 293   // cycle, so we don't need to schedule another composite to address it.
 294   disable_schedule_composite_ = true;
 295   if (root_layer_)
 296     root_layer_->SendDamagedRects();
 297   disable_schedule_composite_ = false;
 298 }
 299
 300 scoped_ptr<cc::OutputSurface> Compositor::CreateOutputSurface(bool fallback) {
 301   return context_factory_->CreateOutputSurface(this, fallback);
 302 }
 303
 304 void Compositor::DidCommit() {
 305   DCHECK(!IsLocked());
 306   FOR_EACH_OBSERVER(CompositorObserver,
 307                     observer_list_,
 308                     OnCompositingDidCommit(this));
 309 }
 310
 311 void Compositor::DidCommitAndDrawFrame() {
 312   base::TimeTicks start_time = gfx::FrameTime::Now();
 313   FOR_EACH_OBSERVER(CompositorObserver,
 314                     observer_list_,
 315                     OnCompositingStarted(this, start_time));
 316 }
 317
 318 void Compositor::DidCompleteSwapBuffers() {
 319   if (compositor_thread_loop_) {
 320     NotifyEnd();
 321   } else {
 322     DCHECK_EQ(swap_state_, SWAP_POSTED);
 323     NotifyEnd();
 324     swap_state_ = SWAP_COMPLETED;
 325   }
 326 }
 327
 328 void Compositor::ScheduleComposite() {
 329   if (!disable_schedule_composite_)
 330     ScheduleDraw();
 331 }
 332
 333 void Compositor::ScheduleAnimation() {
 334   ScheduleComposite();
 335 }
 336
 337 void Compositor::DidPostSwapBuffers() {
 338   DCHECK(!compositor_thread_loop_);
 339   DCHECK_EQ(swap_state_, SWAP_NONE);
 340   swap_state_ = SWAP_POSTED;
 341 }
 342
 343 void Compositor::DidAbortSwapBuffers() {
 344   if (!compositor_thread_loop_) {
 345     if (swap_state_ == SWAP_POSTED) {
 346       NotifyEnd();
 347       swap_state_ = SWAP_COMPLETED;
 348     }
 349   }
 350
 351   FOR_EACH_OBSERVER(CompositorObserver,
 352                     observer_list_,
 353                     OnCompositingAborted(this));
 354 }
 355
 356 void Compositor::ScheduleAnimationForLayerCollection() {
 357   host_->SetNeedsAnimate();
 358 }
 359
 360 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
 361   return host_->debug_state();
 362 }
 363
 364 void Compositor::SetLayerTreeDebugState(
 365     const cc::LayerTreeDebugState& debug_state) {
 366   host_->SetDebugState(debug_state);
 367 }
 368
 369 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
 370   if (!compositor_lock_) {
 371     compositor_lock_ = new CompositorLock(this);
 372     if (compositor_thread_loop_)
 373       host_->SetDeferCommits(true);
 374     FOR_EACH_OBSERVER(CompositorObserver,
 375                       observer_list_,
 376                       OnCompositingLockStateChanged(this));
 377   }
 378   return compositor_lock_;
 379 }
 380
 381 void Compositor::UnlockCompositor() {
 382   DCHECK(compositor_lock_);
 383   compositor_lock_ = NULL;
 384   if (compositor_thread_loop_)
 385     host_->SetDeferCommits(false);
 386   FOR_EACH_OBSERVER(CompositorObserver,
 387                     observer_list_,
 388                     OnCompositingLockStateChanged(this));
 389 }
 390
 391 void Compositor::CancelCompositorLock() {
 392   if (compositor_lock_)
 393     compositor_lock_->CancelLock();
 394 }
 395
 396 void Compositor::NotifyEnd() {
 397   last_ended_frame_++;
 398   TRACE_EVENT_ASYNC_END0("ui", "Compositor::Draw", last_ended_frame_);
 399   waiting_on_compositing_end_ = false;
 400   if (draw_on_compositing_end_) {
 401     draw_on_compositing_end_ = false;
 402
 403     // Call ScheduleDraw() instead of Draw() in order to allow other
 404     // CompositorObservers to be notified before starting another
 405     // draw cycle.
 406     ScheduleDraw();
 407   }
 408   FOR_EACH_OBSERVER(CompositorObserver,
 409                     observer_list_,
 410                     OnCompositingEnded(this));
 411 }
 412
 413 }  // namespace ui