Clear shader disk cache after glProgramBinary failure.

services/ui/gpu/gpu_main.cc

 // Copyright 2016 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 "services/ui/gpu/gpu_main.h"
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
+#include "gpu/command_buffer/common/activity_flags.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "gpu/ipc/gpu_in_process_thread_service.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "services/ui/common/server_gpu_memory_buffer_manager.h"
 #include "services/ui/gpu/gpu_service.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
@@ skipping 91 matching lines @@
   // |this| will outlive the gpu thread and so it's safe to use
   // base::Unretained here.
   gpu_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GpuMain::InitOnGpuThread, base::Unretained(this),
                  io_thread_.task_runner(), compositor_thread_task_runner_));
 }
 
 void GpuMain::CreateGpuService(mojom::GpuServiceRequest request,
                                mojom::GpuHostPtr gpu_host,
-                               const gpu::GpuPreferences& preferences) {
+                               const gpu::GpuPreferences& preferences,
+                               mojo::ScopedSharedBufferHandle activity_flags) {
+  gpu::GpuProcessActivityFlags::InitializeInstance(std::move(activity_flags));

[sadrul, 2017/03/16 04:40:32]

Note that GpuChannelManager is not created in the current thread. Instead, it
gets created by GpuService, in GpuMain::CreateGpuServiceOnGpuThread(). Should
this be initialized in that thread too?

Maybe it'd be simplest to move this GpuProcessActivityFlags initialization into
GpuService::Bind(), or GpuService::InitializeWithHost()? (since GpuService is
used by both this GpuMain, and content::GpuChildThread)

[ericrk, 2017/03/16 21:25:23]

Seems like it shouldn't matter where this is initialized, it's not doing
anything in init other than moving the ScopedSharedBufferHandle and mapping it.

I've re-factored things so we don't use a singleton any more, but instead pass
the GpuProcessActivityFlags through to the GpuChannelManager.

I still create the GpuProcessActivityFlags here, as it seems more
self-documenting to pass that object around rather than a
ScopedSharedBufferHandle... WDYT?

+
   // |this| will outlive the gpu thread and so it's safe to use
   // base::Unretained here.
   gpu_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GpuMain::CreateGpuServiceOnGpuThread, base::Unretained(this),
                  base::Passed(std::move(request)),
                  base::Passed(gpu_host.PassInterface()), preferences));
 }
 
 void GpuMain::CreateDisplayCompositor(
@@ skipping 116 matching lines @@
   // TODO(sad): https://crbug.com/645602
 }
 
 bool GpuMain::EnsureSandboxInitialized(
     gpu::GpuWatchdogThread* watchdog_thread) {
   // TODO(sad): https://crbug.com/645602
   return true;
 }
 
 }  // namespace ui