Initialize RendererSettings in ContextFactory

ui/aura/mus/mus_context_factory.cc

 // Copyright 2015 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/aura/mus/mus_context_factory.h"
 
+#include "base/command_line.h"
 #include "base/memory/ptr_util.h"
+#include "cc/base/switches.h"
 #include "services/ui/public/cpp/gpu/gpu.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/window_tree_host.h"
+#include "ui/compositor/compositor_switches.h"
+#include "ui/display/display_switches.h"
+#include "ui/gfx/switches.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace aura {
 
 MusContextFactory::MusContextFactory(ui::Gpu* gpu)
-    : gpu_(gpu), weak_ptr_factory_(this) {}
+    : gpu_(gpu), weak_ptr_factory_(this) {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  renderer_settings_.partial_swap_enabled =
+      !command_line->HasSwitch(switches::kUIDisablePartialSwap);
+#if defined(OS_WIN)
+  renderer_settings_.finish_rendering_on_resize = true;
+#elif defined(OS_MACOSX)
+  renderer_settings_.release_overlay_resources_after_gpu_query = true;
+#endif
+  renderer_settings_.gl_composited_texture_quad_border =

[danakj, 2017/05/11 15:17:15]

It won't take long for these to diverge from GPTF. Can we find a place to
populate these things and call it from each ContextFactory?
https://cs.chromium.org/chromium/src/content/browser/gpu/compositor_util.h?q=...
comes to mind, but is in content. Maybe now isn't the time to do it yet, since
some of these things are display-compositor-specific and some are shared, and we
should get to the point where that is more clear so they can each go in the
appropriate place? But at the least throw a TODO on each of these blocks?

[Alex Z., 2017/05/11 19:25:22]

I added ui/compositor/compositor_util.* and put 
InitializeRendererSettings in them.

+      command_line->HasSwitch(cc::switches::kGlCompositedTextureQuadBorder);
+  renderer_settings_.show_overdraw_feedback =
+      command_line->HasSwitch(cc::switches::kShowOverdrawFeedback);
+  if (command_line->HasSwitch(switches::kUIEnableRGBA4444Textures))
+    renderer_settings_.preferred_tile_format = cc::RGBA_4444;
+  renderer_settings_.enable_color_correct_rendering =
+      command_line->HasSwitch(switches::kEnableColorCorrectRendering) ||
+      command_line->HasSwitch(switches::kEnableHDR);
+  // Populate buffer_to_texture_target_map for all buffer usage/formats.
+  for (int usage_idx = 0; usage_idx <= static_cast<int>(gfx::BufferUsage::LAST);
+       ++usage_idx) {
+    gfx::BufferUsage usage = static_cast<gfx::BufferUsage>(usage_idx);
+    for (int format_idx = 0;
+         format_idx <= static_cast<int>(gfx::BufferFormat::LAST);
+         ++format_idx) {
+      gfx::BufferFormat format = static_cast<gfx::BufferFormat>(format_idx);
+      // TODO(sad): http://crbug.com/675431
+      uint32_t target = GL_TEXTURE_2D;

[danakj, 2017/05/11 15:17:15]

This makes sharing the code harder, but we could pass in a lambda to provide
this, or maybe resolve the TODO at the same time if we're lucky.

[Alex Z., 2017/05/11 17:28:32]

This used to be ui::Compositor getting the texture target from 
ContextFactory by calling GetImageTextureTarget().

Could you elaborate on "passing in a lambda to provide this"?

[danakj, 2017/05/11 17:34:53]

Like if you need different behaviour in GPTF than other places you have the
helper method take a lambda similar to what the ContextFactory used to provide.
Does that help?

+      renderer_settings_
+          .buffer_to_texture_target_map[std::make_pair(usage, format)] = target;
+    }
+  }
+  renderer_settings_.disallow_non_exact_resource_reuse =
+      command_line->HasSwitch(cc::switches::kDisallowNonExactResourceReuse);
+}
 
 MusContextFactory::~MusContextFactory() {}
 
 void MusContextFactory::OnEstablishedGpuChannel(
     base::WeakPtr<ui::Compositor> compositor,
     scoped_refptr<gpu::GpuChannelHost> gpu_channel) {
   if (!compositor)
     return;
   WindowTreeHost* host =
       WindowTreeHost::GetForAcceleratedWidget(compositor->widget());
@@ skipping 28 matching lines @@
 }
 
 void MusContextFactory::RemoveCompositor(ui::Compositor* compositor) {
   // NOTIMPLEMENTED();
 }
 
 double MusContextFactory::GetRefreshRate() const {
   return 60.0;
 }
 
-uint32_t MusContextFactory::GetImageTextureTarget(gfx::BufferFormat format,
-                                                  gfx::BufferUsage usage) {
-  // TODO(sad): http://crbug.com/675431
-  return GL_TEXTURE_2D;
-}
-
 gpu::GpuMemoryBufferManager* MusContextFactory::GetGpuMemoryBufferManager() {
   return gpu_->gpu_memory_buffer_manager();
 }
 
 cc::TaskGraphRunner* MusContextFactory::GetTaskGraphRunner() {
   return raster_thread_helper_.task_graph_runner();
 }
 
+const cc::RendererSettings& MusContextFactory::GetRendererSettings() const {
+  return renderer_settings_;
+}
+
 }  // namespace aura