cc: Allow sending BeginMainFrame before draw or activation

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 <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 192 matching lines @@
   root_web_layer_ = cc::Layer::Create();
   root_web_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
   settings.refresh_rate =
       ContextFactory::GetInstance()->DoesCreateTestContexts()
       ? kTestRefreshRate
       : kDefaultRefreshRate;
+  settings.start_commit_before_draw_enabled =

[danakj, 2014/02/28 21:19:12]

Did you collect any data for the browser compositor that suggests they are a
good idea there too? The two environments are quite different (commit/paint is
much faster and controlled in the browser).

[brianderson, 2014/02/28 21:36:28]

I have not. Theoretically, this wont make a difference if the Browser compositor
is fast but will allow more concurrency if it is slow.

This also won't make as much sense once we're using SingleThreadProxy+Scheduler
in the Browser because this mainly gives us the benefit of drawing and
committing concurrently when there is an Impl thread and Main thread.

With SingleThreadProxy, prioritizing the commit will defer the draw and will
only give us a concurrency benefit if we can overlap the draw with
impl-side-painting.

Sadly, I was hoping we could get away with just testing the
start_commit_before_draw path. For the LayerTreeHostImpl unit tests, we can
probably get away with tying the value of start_commit_before_draw to
SingleThreadProxy once it has a Scheduler. We'll probably need to fork the
scheduler's unit test though.

[danakj, 2014/02/28 21:52:58]

I'm worried that if we commit sooner we miss renderer frames or user input more
often and increase latency by a frame.
This also depends on a pending tree being present then?
With single-thread impl-side-painting we're expecting to commit directly to the
active tree, so committing before draw would clobber the active tree.

+      cc::switches::IsStartCommitBeforeDrawEnabled();
+  settings.start_commit_before_activate_enabled =
+      cc::switches::IsStartCommitBeforeActivateEnabled();
   settings.partial_swap_enabled =
       !command_line->HasSwitch(cc::switches::kUIDisablePartialSwap);
 #if defined(OS_CHROMEOS)
   settings.per_tile_painting_enabled = true;
 #endif
 
   // These flags should be mirrored by renderer versions in content/renderer/.
   settings.initial_debug_state.show_debug_borders =
       command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders);
   settings.initial_debug_state.show_fps_counter =
@@ skipping 332 matching lines @@
     // CompositorObservers to be notified before starting another
     // draw cycle.
     ScheduleDraw();
   }
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingEnded(this));
 }
 
 }  // namespace ui