Initialize RendererSettings in ContextFactory

ui/compositor/test/in_process_context_factory.cc

 // Copyright 2014 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/test/in_process_context_factory.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread.h"
+#include "cc/base/switches.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/output_surface_frame.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/surfaces/direct_compositor_frame_sink.h"
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/local_surface_id_allocator.h"
 #include "cc/test/pixel_test_output_surface.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/reflector.h"
 #include "ui/compositor/test/in_process_context_provider.h"
+#include "ui/display/display_switches.h"
+#include "ui/gfx/switches.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/test/gl_surface_test_support.h"
 
 #if !defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW)
 #include "gpu/ipc/common/gpu_surface_tracker.h"
 #endif
 
 namespace ui {
 namespace {
 // The client_id used here should not conflict with the client_id generated
@@ skipping 90 matching lines @@
 
 InProcessContextFactory::InProcessContextFactory(
     cc::SurfaceManager* surface_manager)
     : frame_sink_id_allocator_(kDefaultClientId),
       use_test_surface_(true),
       surface_manager_(surface_manager) {
   DCHECK(surface_manager);
   DCHECK_NE(gl::GetGLImplementation(), gl::kGLImplementationNone)
       << "If running tests, ensure that main() is calling "
       << "gl::GLSurfaceTestSupport::InitializeOneOff()";
+
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();

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

same here regarding tests

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

Done.

+  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 =
+      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);
+      uint32_t target = GL_TEXTURE_2D;
+      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);
 }
 
 InProcessContextFactory::~InProcessContextFactory() {
   DCHECK(per_compositor_data_.empty());
 }
 
 void InProcessContextFactory::SendOnLostResources() {
   for (auto& observer : observer_list_)
     observer.OnLostResources();
 }
@@ skipping 55 matching lines @@
 
   std::unique_ptr<cc::DelayBasedBeginFrameSource> begin_frame_source(
       new cc::DelayBasedBeginFrameSource(
           base::MakeUnique<cc::DelayBasedTimeSource>(
               compositor->task_runner().get())));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       compositor->task_runner().get(),
       display_output_surface->capabilities().max_frames_pending));
 
   data->display = base::MakeUnique<cc::Display>(
-      &shared_bitmap_manager_, &gpu_memory_buffer_manager_,
-      compositor->GetRendererSettings(), compositor->frame_sink_id(),
-      begin_frame_source.get(), std::move(display_output_surface),
-      std::move(scheduler), base::MakeUnique<cc::TextureMailboxDeleter>(
-                                compositor->task_runner().get()));
+      &shared_bitmap_manager_, &gpu_memory_buffer_manager_, renderer_settings_,
+      compositor->frame_sink_id(), begin_frame_source.get(),
+      std::move(display_output_surface), std::move(scheduler),
+      base::MakeUnique<cc::TextureMailboxDeleter>(
+          compositor->task_runner().get()));
   // Note that we are careful not to destroy a prior |data->begin_frame_source|
   // until we have reset |data->display|.
   data->begin_frame_source = std::move(begin_frame_source);
 
   auto* display = per_compositor_data_[compositor.get()]->display.get();
   auto compositor_frame_sink = base::MakeUnique<cc::DirectCompositorFrameSink>(
       compositor->frame_sink_id(), surface_manager_, display, context_provider,
       shared_worker_context_provider_, &gpu_memory_buffer_manager_,
       &shared_bitmap_manager_);
   compositor->SetCompositorFrameSink(std::move(compositor_frame_sink));
@@ skipping 36 matching lines @@
   if (data->surface_handle)
     gpu::GpuSurfaceTracker::Get()->RemoveSurface(data->surface_handle);
 #endif
   per_compositor_data_.erase(it);
 }
 
 double InProcessContextFactory::GetRefreshRate() const {
   return refresh_rate_;
 }
 
-uint32_t InProcessContextFactory::GetImageTextureTarget(
-    gfx::BufferFormat format,
-    gfx::BufferUsage usage) {
-  return GL_TEXTURE_2D;
-}
-
 gpu::GpuMemoryBufferManager*
 InProcessContextFactory::GetGpuMemoryBufferManager() {
   return &gpu_memory_buffer_manager_;
 }
 
 cc::TaskGraphRunner* InProcessContextFactory::GetTaskGraphRunner() {
   return &task_graph_runner_;
 }
 
 cc::FrameSinkId InProcessContextFactory::AllocateFrameSinkId() {
@@ skipping 11 matching lines @@
   per_compositor_data_[compositor]->display->SetVisible(visible);
 }
 
 void InProcessContextFactory::ResizeDisplay(ui::Compositor* compositor,
                                             const gfx::Size& size) {
   if (!per_compositor_data_.count(compositor))
     return;
   per_compositor_data_[compositor]->display->Resize(size);
 }
 
+const cc::RendererSettings& InProcessContextFactory::GetRendererSettings()
+    const {
+  return renderer_settings_;
+}
+
 void InProcessContextFactory::AddObserver(ContextFactoryObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void InProcessContextFactory::RemoveObserver(ContextFactoryObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 InProcessContextFactory::PerCompositorData*
 InProcessContextFactory::CreatePerCompositorData(ui::Compositor* compositor) {
@@ skipping 23 matching lines @@
             ));
 #endif
   }
 
   PerCompositorData* return_ptr = data.get();
   per_compositor_data_[compositor] = std::move(data);
   return return_ptr;
 }
 
 }  // namespace ui