CC: Plumb LayerSettings parameter for cc::Layer construction.

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 63 matching lines @@
       surface_id_allocator_(context_factory->CreateSurfaceIdAllocator()),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
       locks_will_time_out_(true),
       compositor_lock_(NULL),
       layer_animator_collection_(this),
       weak_ptr_factory_(this) {
-  root_web_layer_ = cc::Layer::Create();
-
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
+
+  cc::LayerSettings ui_layer_settings;
+  if (command_line->HasSwitch(
+          switches::kUIEnableCompositorAnimationTimelines)) {
+    ui_layer_settings.use_compositor_animation_timelines = true;
+  }
+  Layer::SetUILayerSettings(ui_layer_settings);

[piman, 2015/05/12 20:06:54]

I think we should do this initialization only once, rather than for every new
ui::Compositor. We can move that code to the ContextFactory initialization -
there's only 2: GpuProcessTransportFactory in
content/browser/compositor/gpu_process_transport_factory.cc (for production) and
InProcessContextFactory in 
ui/compositor/test/in_process_context_factory.cc (for tests). You can move this
code into a static ui::Layer::InitializeLayerSettings() and call it from those 2
places.

[loyso (OOO), 2015/05/19 04:21:48]

Done.

+
+  settings.hud_layer_settings = Layer::UILayerSettings();
+
+  root_web_layer_ = cc::Layer::Create(Layer::UILayerSettings());
+
   // When impl-side painting is enabled, this will ensure PictureLayers always
   // can have LCD text, to match the previous behaviour with ContentLayers,
   // where LCD-not-allowed notifications were ignored.
   settings.layers_always_allowed_lcd_text = true;
   settings.renderer_settings.refresh_rate =
       context_factory_->DoesCreateTestContexts() ? kTestRefreshRate
                                                  : kDefaultRefreshRate;
   settings.main_frame_before_activation_enabled = false;
   settings.throttle_frame_production =
       !command_line->HasSwitch(switches::kDisableGpuVsync);
@@ skipping 30 matching lines @@
   settings.impl_side_painting = IsUIImplSidePaintingEnabled();
   settings.use_display_lists = IsUISlimmingPaintEnabled();
   settings.use_cached_picture_in_display_list = false;
   settings.use_zero_copy = IsUIZeroCopyEnabled();
   settings.use_one_copy = IsUIOneCopyEnabled();
   settings.use_image_texture_target = context_factory_->GetImageTextureTarget();
   // Note: gathering of pixel refs is only needed when using multiple
   // raster threads.
   settings.gather_pixel_refs = false;
 
-  settings.use_compositor_animation_timelines =
-      command_line->HasSwitch(switches::kUIEnableCompositorAnimationTimelines);
-
   base::TimeTicks before_create = base::TimeTicks::Now();
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.shared_bitmap_manager = context_factory_->GetSharedBitmapManager();
   params.gpu_memory_buffer_manager =
       context_factory_->GetGpuMemoryBufferManager();
   params.task_graph_runner = context_factory_->GetTaskGraphRunner();
   params.settings = &settings;
   params.main_task_runner = task_runner_;
@@ skipping 279 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui