Add DriverBugWorkaroundsInGpuProcessPage to gpu_process_test.py

content/common/gpu/gpu_channel.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/common/gpu/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 742 matching lines @@
   RemoveRouteFromStream(route_id);
 }
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateCommandBuffer,
                         OnCreateCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
                         OnDestroyCommandBuffer)
+    IPC_MESSAGE_HANDLER(GpuChannelMsg_GetDriverBugWorkArounds,
+                        OnGetDriverBugWorkArounds)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 scoped_refptr<gpu::SyncPointOrderData> GpuChannel::GetSyncPointOrderData(
     int32_t stream_id) {
   auto it = streams_.find(stream_id);
   DCHECK(it != streams_.end());
   DCHECK(it->second);
@@ skipping 111 matching lines @@
 void GpuChannel::RemoveRouteFromStream(int32_t route_id) {
   DCHECK(routes_to_streams_.find(route_id) != routes_to_streams_.end());
   int32_t stream_id = routes_to_streams_[route_id];
   DCHECK(streams_.find(stream_id) != streams_.end());
   routes_to_streams_.erase(route_id);
   streams_to_num_routes_[stream_id]--;
   filter_->RemoveRoute(route_id);
   DestroyStreamIfNecessary(streams_[stream_id]);
 }
 
-#if defined(OS_ANDROID)
 const GpuCommandBufferStub* GpuChannel::GetOneStub() const {
   for (const auto& kv : stubs_) {
     const GpuCommandBufferStub* stub = kv.second;
     if (stub->decoder() && !stub->decoder()->WasContextLost())
       return stub;
   }
   return nullptr;
 }
-#endif
 
 void GpuChannel::OnCreateCommandBuffer(
     gpu::SurfaceHandle surface_handle,
     const gfx::Size& size,
     const GPUCreateCommandBufferConfig& init_params,
     int32_t route_id,
     bool* succeeded) {
   TRACE_EVENT2("gpu", "GpuChannel::OnCreateCommandBuffer", "route_id", route_id,
                "offscreen", (surface_handle == gpu::kNullSurfaceHandle));
   *succeeded = false;
@@ skipping 57 matching lines @@
   // In case the renderer is currently blocked waiting for a sync reply from the
   // stub, we need to make sure to reschedule the correct stream here.
   if (stub && !stub->IsScheduled()) {
     // This stub won't get a chance to reschedule the stream so do that now.
     OnStreamRescheduled(stub->stream_id(), true);
   }
 
   RemoveRoute(route_id);
 }
 
+void GpuChannel::OnGetDriverBugWorkArounds(
+    std::vector<std::string>* gpu_driver_bug_workarounds) {
+  const GpuCommandBufferStub* stub = GetOneStub();
+  if (stub) {

[piman, 2016/03/31 01:44:21]

This sounds potentially flaky - the IPC result depends on unrelated state (e.g.
whether or not the compositor has initialized).

If all you want is the workarounds, maybe you can refactor the code from
FeatureInfo that extracts them from the command-line, and move it to, say,
GpuChannelManager: the result is constant, and there's no point in doing it once
per context, actually.

[Julien Isorce Samsung, 2016/03/31 15:20:09]

I was not able to understand why it is done once per context so I just assumed
it was necessary somehow. Good idea about moving it to GpuChannelManager, I'll
try.

+    std::vector<std::string> workaround_names;
+#define GPU_OP(type, name)                        \
+  if (stub->GetFeatureInfo()->workarounds().name) \
+    workaround_names.push_back(#name);
+    GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
+#undef GPU_OP
+    *gpu_driver_bug_workarounds = workaround_names;

[dcheng, 2016/03/30 23:45:25]

std::move() if you're feeling fancy. Alternatively, any reason to not just
clear() and push_back() directly into the output vector?

[Julien Isorce Samsung, 2016/03/31 15:20:09]

No particular reason, I thought about you second suggestion but I was not
confident enough, no particular reason :) So I'll do what you suggested.

+  }
+}
+
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
   gpu_channel_manager_->delegate()->StoreShaderToDisk(client_id_, key, shader);
 }
 
 void GpuChannel::AddFilter(IPC::MessageFilter* filter) {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuChannelMessageFilter::AddChannelFilter,
                             filter_, make_scoped_refptr(filter)));
 }
@@ skipping 53 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content