cc: Fix the format of GpuMemoryBuffer for SurfaceTexture

content/renderer/render_thread_impl.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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 404 matching lines @@
 
  private:
   mojo::StrongBinding<EmbeddedWorkerSetup> binding_;
 };
 
 void CreateEmbeddedWorkerSetup(
     mojo::InterfaceRequest<EmbeddedWorkerSetup> request) {
   new EmbeddedWorkerSetupImpl(request.Pass());
 }
 
+void StringToUintVector(const std::string& str, std::vector<unsigned>* vector) {
+  DCHECK(vector->empty());
+  std::vector<std::string> pieces;
+  base::SplitString(str, ',', &pieces);
+  DCHECK_EQ(pieces.size(), static_cast<size_t>(gfx::BufferFormat::LAST) + 1);
+  for (size_t i = 0; i < pieces.size(); ++i) {
+    unsigned number = 0;
+    bool succeed = base::StringToUint(pieces[i], &number);
+    DCHECK(succeed);
+    vector->push_back(number);
+  }
+}
+
 }  // namespace
 
 // For measuring memory usage after each task. Behind a command line flag.
 class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
   MemoryObserver() {}
   ~MemoryObserver() override {}
 
   void WillProcessTask(const base::PendingTask& pending_task) override {}
 
@@ skipping 212 matching lines @@
         key, kCFPreferencesCurrentApplication, &key_exists);
     if (key_exists && !value)
       is_elastic_overscroll_enabled_ = false;
   }
 #else
   is_elastic_overscroll_enabled_ = false;
 #endif
 
   std::string image_texture_target_string =
       command_line.GetSwitchValueASCII(switches::kContentImageTextureTarget);
-  bool parsed_image_texture_target = base::StringToUint(
-      image_texture_target_string, &use_image_texture_target_);
-  DCHECK(parsed_image_texture_target);
+  StringToUintVector(image_texture_target_string, &use_image_texture_targets_);
 
   if (command_line.HasSwitch(switches::kDisableLCDText)) {
     is_lcd_text_enabled_ = false;
   } else if (command_line.HasSwitch(switches::kEnableLCDText)) {
     is_lcd_text_enabled_ = true;
   } else {
 #if defined(OS_ANDROID)
     is_lcd_text_enabled_ = false;
 #else
     is_lcd_text_enabled_ = true;
@@ skipping 660 matching lines @@
                 lose_context_when_out_of_memory,
                 GURL("chrome://gpu/RenderThreadImpl::GetGpuVDAContext3D"),
                 WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
                 NULL)),
         GPU_VIDEO_ACCELERATOR_CONTEXT);
   }
   if (gpu_va_context_provider_.get()) {
     bool enable_video_accelerator =
         !cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode);
     std::string image_texture_target_string =
-        cmd_line->GetSwitchValueASCII(switches::kContentImageTextureTarget);
+        cmd_line->GetSwitchValueASCII(switches::kVideoImageTextureTarget);
     unsigned image_texture_target = 0;
     bool parsed_image_texture_target =
         base::StringToUint(image_texture_target_string, &image_texture_target);
     DCHECK(parsed_image_texture_target);
     CHECK(gpu_channel_.get()) << "Have gpu_va_context_provider but no "
                                  "gpu_channel_. See crbug.com/495185.";
     CHECK(gpu_channel_host.get()) << "Have gpu_va_context_provider but lost "
                                      "gpu_channel_. See crbug.com/495185.";
     gpu_factories = RendererGpuVideoAcceleratorFactories::Create(
         gpu_channel_host.get(), media_task_runner, gpu_va_context_provider_,
@@ skipping 108 matching lines @@
 }
 
 bool RenderThreadImpl::IsOneCopyEnabled() {
   return is_one_copy_enabled_;
 }
 
 bool RenderThreadImpl::IsElasticOverscrollEnabled() {
   return is_elastic_overscroll_enabled_;
 }
 
-uint32 RenderThreadImpl::GetImageTextureTarget() {
-  return use_image_texture_target_;
+std::vector<unsigned> RenderThreadImpl::GetImageTextureTargets() {
+  return use_image_texture_targets_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RenderThreadImpl::GetCompositorMainThreadTaskRunner() {
   return main_thread_compositor_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RenderThreadImpl::GetCompositorImplThreadTaskRunner() {
   return compositor_task_runner_;
@@ skipping 451 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content