aura: Drop unnecessary composites

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include "base/command_line.h"
 #include "base/threading/thread_restrictions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositor.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebFloatPoint.h"
@@ skipping 113 matching lines @@
 Texture::~Texture() {
 }
 
 Compositor::Compositor(CompositorDelegate* delegate,
                        gfx::AcceleratedWidget widget)
     : delegate_(delegate),
       root_layer_(NULL),
       widget_(widget),
       root_web_layer_(WebKit::WebLayer::create()),
       swap_posted_(false),
-      device_scale_factor_(0.0f) {
+      device_scale_factor_(0.0f),
+      last_started_frame_(0),
+      last_ended_frame_(0),
+      disable_schedule_composite_(false) {
   WebKit::WebLayerTreeView::Settings settings;
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   settings.showFPSCounter =
       command_line->HasSwitch(switches::kUIShowFPSCounter);
   settings.showPlatformLayerTree =
       command_line->HasSwitch(switches::kUIShowLayerTree);
   settings.refreshRate = test_compositor_enabled ?
       kTestRefreshRate : kDefaultRefreshRate;
   settings.partialSwapEnabled =
       command_line->HasSwitch(switches::kUIEnablePartialSwap);
@@ skipping 26 matching lines @@
 void Compositor::Terminate() {
   WebKit::WebCompositor::shutdown();
   if (g_compositor_thread) {
     delete g_compositor_thread;
     g_compositor_thread = NULL;
   }
 }
 
 void Compositor::ScheduleDraw() {
   if (g_compositor_thread) {
+    disable_schedule_composite_ = true;

[piman, 2012/06/06 20:17:24]

nit: it's probably not useful to do this here, since it's done in layout()
anyway.

[jonathan.backer, 2012/06/06 20:31:43]

Thanks. Tried to squeeze this in before a meeting. I shouldn't have rushed.

     // TODO(nduca): Temporary while compositor calls
     // compositeImmediately() directly.
     layout();
+    disable_schedule_composite_ = false;
     host_.composite();
   } else if (delegate_) {
     delegate_->ScheduleDraw();
   }
 }
 
 void Compositor::SetRootLayer(Layer* root_layer) {
   if (root_layer_ == root_layer)
     return;
   if (root_layer_)
     root_layer_->SetCompositor(NULL);
   root_layer_ = root_layer;
   if (root_layer_ && !root_layer_->GetCompositor())
     root_layer_->SetCompositor(this);
   root_web_layer_.removeAllChildren();
   if (root_layer_)
     root_web_layer_.addChild(root_layer_->web_layer());
 }
 
 void Compositor::Draw(bool force_clear) {
   if (!root_layer_)
     return;
 
+  last_started_frame_++;
+
   // TODO(nduca): Temporary while compositor calls
   // compositeImmediately() directly.
   layout();
   host_.composite();
   if (!g_compositor_thread && !swap_posted_)
     NotifyEnd();
 }
 
 void Compositor::ScheduleFullDraw() {
   host_.setNeedsRedraw();
@@ skipping 66 matching lines @@
   }
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingAborted(this));
 }
 
 void Compositor::updateAnimations(double frameBeginTime) {
 }
 
 void Compositor::layout() {
+  // We're sending damage that will be addressed during this composite
+  // cycle, so we don't need to schedule another composite to address it.
+  disable_schedule_composite_ = true;
   if (root_layer_)
     root_layer_->SendDamagedRects();
+  disable_schedule_composite_ = false;
 }
 
 void Compositor::applyScrollAndScale(const WebKit::WebSize& scrollDelta,
                                      float scaleFactor) {
 }
 
 WebKit::WebGraphicsContext3D* Compositor::createContext3D() {
   if (test_compositor_enabled) {
     ui::TestWebGraphicsContext3D* test_context =
       new ui::TestWebGraphicsContext3D();
@@ skipping 11 matching lines @@
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingStarted(this));
 }
 
 void Compositor::didCompleteSwapBuffers() {
   NotifyEnd();
 }
 
 void Compositor::scheduleComposite() {
-  ScheduleDraw();
+  if (!disable_schedule_composite_)
+    ScheduleDraw();
 }
 
 void Compositor::SwizzleRGBAToBGRAAndFlip(unsigned char* pixels,
                                           const gfx::Size& image_size) {
   // Swizzle from RGBA to BGRA
   size_t bitmap_size = 4 * image_size.width() * image_size.height();
   for(size_t i = 0; i < bitmap_size; i += 4)
     std::swap(pixels[i], pixels[i + 2]);
 
   // Vertical flip to transform from GL co-ords
   size_t row_size = 4 * image_size.width();
   scoped_array<unsigned char> tmp_row(new unsigned char[row_size]);
   for(int row = 0; row < image_size.height() / 2; row++) {
     memcpy(tmp_row.get(),
            &pixels[row * row_size],
            row_size);
     memcpy(&pixels[row * row_size],
            &pixels[bitmap_size - (row + 1) * row_size],
            row_size);
     memcpy(&pixels[bitmap_size - (row + 1) * row_size],
            tmp_row.get(),
            row_size);
   }
 }
 
 void Compositor::NotifyEnd() {
+  last_ended_frame_++;
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingEnded(this));
 }
 
 COMPOSITOR_EXPORT void SetupTestCompositor() {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableTestCompositor)) {
     test_compositor_enabled = true;
   }
 #if defined(OS_CHROMEOS)
   // If the test is running on the chromeos envrionment (such as
   // device or vm bots), use the real compositor.
   if (base::chromeos::IsRunningOnChromeOS())
     test_compositor_enabled = false;
 #endif
 }
 
 COMPOSITOR_EXPORT void DisableTestCompositor() {
   test_compositor_enabled = false;
 }
 
 COMPOSITOR_EXPORT bool IsTestCompositorEnabled() {
   return test_compositor_enabled;
 }
 
 }  // namespace ui