Fix use_image_texture_target inconsistencies

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 26 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/supports_user_data.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/tracked_objects.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
+#include "cc/output/renderer_settings.h"
 #include "components/scheduler/common/scheduler_switches.h"
 #include "components/tracing/common/tracing_switches.h"
 #include "components/webmessaging/broadcast_channel_provider.h"
 #include "content/browser/appcache/appcache_dispatcher_host.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/background_sync/background_sync_service_impl.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/blob_storage/blob_dispatcher_host.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/browser_child_process_host_impl.h"
@@ skipping 372 matching lines @@
   void Release(int old_route_id) {
     session_storage_namespaces_awaiting_close_.erase(old_route_id);
   }
 
  private:
   std::map<int, SessionStorageNamespaceMap>
       session_storage_namespaces_awaiting_close_;
   DISALLOW_COPY_AND_ASSIGN(SessionStorageHolder);
 };
 
-std::string UintVectorToString(const std::vector<unsigned>& vector) {
+// Converts an ImageTextureTargetsMap to a string representation of the format:
+// "usage,format,target;usage,format,target;...;usage,format,target"
+std::string ImageTextureTargetsMapToString(
+    const cc::RendererSettings::ImageTextureTargetsMap& map) {
   std::string str;
-  for (auto it : vector) {
+  for (const auto& entry : map) {
     if (!str.empty())
-      str += ",";
-    str += base::UintToString(it);
+      str += ";";
+    str += base::UintToString(static_cast<uint32_t>(entry.first.first));
+    str += ",";
+    str += base::UintToString(static_cast<uint32_t>(entry.first.second));
+    str += ",";
+    str += base::UintToString(entry.second);
   }
   return str;
 }
 
 }  // namespace
 
 RendererMainThreadFactoryFunction g_renderer_main_thread_factory = NULL;
 
 base::MessageLoop* g_in_process_thread;
 
@@ skipping 828 matching lines @@
     command_line->AppendSwitch(switches::kForceGpuRasterization);
 
   if (IsGpuMemoryBufferCompositorResourcesEnabled()) {
     command_line->AppendSwitch(
         switches::kEnableGpuMemoryBufferCompositorResources);
   }
 
   if (IsMainFrameBeforeActivationEnabled())
     command_line->AppendSwitch(cc::switches::kEnableMainFrameBeforeActivation);
 
-  // Persistent buffers may come at a performance hit (not all platform specific
-  // buffers support it), so only enable them if partial raster is enabled and
-  // we are actually going to use them.
-  // TODO(dcastagna): Once GPU_READ_CPU_READ_WRITE_PERSISTENT is removed
-  // kContentImageTextureTarget and kVideoImageTextureTarget can be merged into
-  // one flag.
-  gfx::BufferUsage buffer_usage =
-      IsPartialRasterEnabled()
-          ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
-          : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE;
-  std::vector<unsigned> image_targets(
-      static_cast<size_t>(gfx::BufferFormat::LAST) + 1, GL_TEXTURE_2D);
-  for (size_t format = 0;
-       format < static_cast<size_t>(gfx::BufferFormat::LAST) + 1; format++) {
-    image_targets[format] =
-        BrowserGpuMemoryBufferManager::GetImageTextureTarget(
-            static_cast<gfx::BufferFormat>(format), buffer_usage);
+  cc::RendererSettings::ImageTextureTargetsMap image_targets;
+  for (size_t usage_idx = 0;
+       usage_idx <= static_cast<size_t>(gfx::BufferUsage::LAST) + 1;
+       ++usage_idx) {
+    gfx::BufferUsage usage = static_cast<gfx::BufferUsage>(usage_idx);
+    for (size_t format_idx = 0;
+         format_idx < static_cast<size_t>(gfx::BufferFormat::LAST) + 1;
+         ++format_idx) {
+      gfx::BufferFormat format = static_cast<gfx::BufferFormat>(format_idx);
+      uint32_t target =
+          BrowserGpuMemoryBufferManager::GetImageTextureTarget(format, usage);
+      image_targets.emplace(
+          cc::RendererSettings::ImageTextureTargetKey(usage, format), target);
+    }
   }
-  command_line->AppendSwitchASCII(switches::kContentImageTextureTarget,
-                                  UintVectorToString(image_targets));
-
-  for (size_t format = 0;
-       format < static_cast<size_t>(gfx::BufferFormat::LAST) + 1; format++) {
-    image_targets[format] =
-        BrowserGpuMemoryBufferManager::GetImageTextureTarget(
-            static_cast<gfx::BufferFormat>(format),
-            gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
-  }
-  command_line->AppendSwitchASCII(switches::kVideoImageTextureTarget,
-                                  UintVectorToString(image_targets));
+  command_line->AppendSwitchASCII(
+      switches::kContentImageTextureTarget,
+      ImageTextureTargetsMapToString(image_targets));
 
   // Appending disable-gpu-feature switches due to software rendering list.
   GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance();
   DCHECK(gpu_data_manager);
   gpu_data_manager->AppendRendererCommandLine(command_line);
 }
 
 void RenderProcessHostImpl::AppendRendererCommandLine(
     base::CommandLine* command_line) const {
   // Pass the process type first, so it shows first in process listings.
@@ skipping 1434 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing. Alias
   // enough information here so that we can determine what the bad message was.
   base::debug::Alias(&error);
   bad_message::ReceivedBadMessage(process.get(),
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content