gpu: Reduce of BrowserGpuChannelHostFactory.

content/browser/gpu/gpu_ipc_browsertests.cc

 // Copyright 2013 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 "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
+#include "content/browser/browser_main_loop.h"
 #include "content/browser/compositor/image_transport_factory.h"
-#include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/gpu_stream_constants.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/gpu_utils.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/content_browser_test.h"
+#include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/ui/gpu/interfaces/gpu_service.mojom.h"
 #include "services/ui/public/cpp/gpu/context_provider_command_buffer.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "ui/gl/gl_switches.h"
 
 namespace {
 
@@ skipping 25 matching lines @@
     *retvalue = std::move(established_host);
   quit_closure.Run();
 }
 
 class EstablishGpuChannelHelper {
  public:
   EstablishGpuChannelHelper() {}
   ~EstablishGpuChannelHelper() {}
 
   scoped_refptr<gpu::GpuChannelHost> EstablishGpuChannelSyncRunLoop() {
-    if (!content::BrowserGpuChannelHostFactory::instance())
-      content::BrowserGpuChannelHostFactory::Initialize(true);
-
-    content::BrowserGpuChannelHostFactory* factory =
-        content::BrowserGpuChannelHostFactory::instance();
+    gpu::GpuChannelEstablishFactory* factory =
+        content::BrowserMainLoop::GetInstance()
+            ->gpu_channel_establish_factory();
     CHECK(factory);
     base::RunLoop run_loop;
     factory->EstablishGpuChannel(base::Bind(
         &OnEstablishedGpuChannel, run_loop.QuitClosure(), &gpu_channel_host_));
     run_loop.Run();
     return std::move(gpu_channel_host_);
   }
 
  private:
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host_;
   DISALLOW_COPY_AND_ASSIGN(EstablishGpuChannelHelper);
 };
 
 class ContextTestBase : public content::ContentBrowserTest {
  public:
   void SetUpOnMainThread() override {
     // This may leave the provider_ null in some cases, so tests need to early
     // out.
-    if (!content::BrowserGpuChannelHostFactory::CanUseForTesting())
+    if (!content::GpuDataManager::GetInstance()->GpuAccessAllowed(nullptr))
       return;
 
     EstablishGpuChannelHelper helper;
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host =
         helper.EstablishGpuChannelSyncRunLoop();
     CHECK(gpu_channel_host);
 
     provider_ = CreateContext(std::move(gpu_channel_host));
     bool bound = provider_->BindToCurrentThread();
     CHECK(bound);
@@ skipping 21 matching lines @@
 
 // Include the shared tests.
 #define CONTEXT_TEST_F IN_PROC_BROWSER_TEST_F
 #include "gpu/ipc/client/gpu_context_tests.h"
 
 namespace content {
 
 class BrowserGpuChannelHostFactoryTest : public ContentBrowserTest {
  public:
   void SetUpOnMainThread() override {
-    if (!BrowserGpuChannelHostFactory::CanUseForTesting())
+    if (!GpuDataManager::GetInstance()->GpuAccessAllowed(nullptr))
       return;
-
-    // Start all tests without a gpu channel so that the tests exercise a
-    // consistent codepath.
-    if (!BrowserGpuChannelHostFactory::instance())
-      BrowserGpuChannelHostFactory::Initialize(false);

[piman, 2017/07/05 17:48:15]

What is the replacement for this? Without this I'm afraid we'll introduce
flakiness.

[sadrul, 2017/07/05 18:39:51]

The initialization in BrowserMainLoop [1] should always have created the
BrowserGpuChannelHostFactory instance by the time we reach here. So this (or
something equivalent) should not be needed here?

[1]
https://cs.chromium.org/chromium/src/content/browser/browser_main_loop.cc?sq=...

[piman, 2017/07/05 18:58:36]

Ok, thanks. That probably explains some of the flakiness in tests and why
they're disabled on many platforms.

Maybe with the mojo refactoring we can make all this more testable.

     CHECK(GetFactory());
-
     ContentBrowserTest::SetUpOnMainThread();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Start all tests without a gpu channel so that the tests exercise a
     // consistent codepath.
     command_line->AppendSwitch(switches::kDisableGpuEarlyInit);
   }
 
   void OnContextLost(const base::Closure callback, int* counter) {
     (*counter)++;
     callback.Run();
   }
 
   void Signal(bool* event,
               scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) {
     CHECK_EQ(*event, false);
     *event = true;
     gpu_channel_host_ = std::move(gpu_channel_host);
   }
 
  protected:
-  BrowserGpuChannelHostFactory* GetFactory() {
-    return BrowserGpuChannelHostFactory::instance();
+  gpu::GpuChannelEstablishFactory* GetFactory() {
+    return BrowserMainLoop::GetInstance()->gpu_channel_establish_factory();
   }
 
   bool IsChannelEstablished() {
     return gpu_channel_host_ && !gpu_channel_host_->IsLost();
   }
 
   void EstablishAndWait() {
     EstablishGpuChannelHelper helper;
     gpu_channel_host_ = helper.EstablishGpuChannelSyncRunLoop();
   }
@@ skipping 134 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(GpuProcessHostBrowserTest, Shutdown) {
   DCHECK(!IsChannelEstablished());
   EstablishAndWait();
   base::RunLoop run_loop;
   StopGpuProcess(run_loop.QuitClosure());
   run_loop.Run();
 }
 
 }  // namespace content