gpu: Introduce GpuChannelEstablishFactory.

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/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
@@ skipping 26 matching lines @@
   attributes.bind_generates_resource = false;
   constexpr bool automatic_flushes = false;
   constexpr bool support_locking = false;
   return make_scoped_refptr(new content::ContextProviderCommandBuffer(
       std::move(gpu_channel_host), gpu::GPU_STREAM_DEFAULT,
       gpu::GpuStreamPriority::NORMAL, gpu::kNullSurfaceHandle, GURL(),
       automatic_flushes, support_locking, gpu::SharedMemoryLimits(), attributes,
       nullptr, content::command_buffer_metrics::OFFSCREEN_CONTEXT_FOR_TESTING));
 }
 
-class ContextTestBase : public content::ContentBrowserTest {
+void OnEstablishedGpuChannel(
+    const base::Closure& quit_closure,
+    scoped_refptr<gpu::GpuChannelHost>* retvalue,
+    scoped_refptr<gpu::GpuChannelHost> established_host) {
+  if (retvalue)
+    *retvalue = std::move(established_host);
+  quit_closure.Run();
+}
+
+class EstablishGpuChannelHelper {
  public:
-  void SetUpOnMainThread() override {
-    // This may leave the provider_ null in some cases, so tests need to early
-    // out.
-    if (!content::BrowserGpuChannelHostFactory::CanUseForTesting())
-      return;
+  EstablishGpuChannelHelper() {}
+  ~EstablishGpuChannelHelper() {}
 
+  scoped_refptr<gpu::GpuChannelHost> EstablishGpuChannelSyncRunLoop() {
     if (!content::BrowserGpuChannelHostFactory::instance())
       content::BrowserGpuChannelHostFactory::Initialize(true);
 
     content::BrowserGpuChannelHostFactory* factory =
         content::BrowserGpuChannelHostFactory::instance();
     CHECK(factory);
     base::RunLoop run_loop;
-    factory->EstablishGpuChannel(kInitCause, run_loop.QuitClosure());
+    factory->EstablishGpuChannel(
+        kInitCause, base::Bind(&OnEstablishedGpuChannel, run_loop.QuitClosure(),
+                               &gpu_channel_host_));
     run_loop.Run();
-    scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
-        factory->GetGpuChannel());
+    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())
+      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);
     gl_ = provider_->ContextGL();
     context_support_ = provider_->ContextSupport();
 
     ContentBrowserTest::SetUpOnMainThread();
   }
@@ skipping 40 matching lines @@
     // 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();
   }
 
   bool IsChannelEstablished() {
-    return GetFactory()->GetGpuChannel() != NULL;
+    return gpu_channel_host_ && !gpu_channel_host_->IsLost();
   }
 
   void EstablishAndWait() {
-    base::RunLoop run_loop;
-    GetFactory()->EstablishGpuChannel(kInitCause, run_loop.QuitClosure());
-    run_loop.Run();
+    EstablishGpuChannelHelper helper;
+    gpu_channel_host_ = helper.EstablishGpuChannelSyncRunLoop();
   }
 
-  gpu::GpuChannelHost* GetGpuChannel() { return GetFactory()->GetGpuChannel(); }
+  gpu::GpuChannelHost* GetGpuChannel() { return gpu_channel_host_.get(); }
 
-  static void Signal(bool *event) {
-    CHECK_EQ(*event, false);
-    *event = true;
-  }
+  scoped_refptr<gpu::GpuChannelHost> gpu_channel_host_;
 };
 
 // Test fails on Chromeos + Mac, flaky on Windows because UI Compositor
 // establishes a GPU channel.
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #define MAYBE_Basic Basic
 #else
 #define MAYBE_Basic DISABLED_Basic
 #endif
 IN_PROC_BROWSER_TEST_F(BrowserGpuChannelHostFactoryTest, MAYBE_Basic) {
   DCHECK(!IsChannelEstablished());
   EstablishAndWait();
   EXPECT_TRUE(GetGpuChannel() != NULL);
 }
 
 // Test fails on Chromeos + Mac, flaky on Windows because UI Compositor
 // establishes a GPU channel.
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #define MAYBE_EstablishAndTerminate EstablishAndTerminate
 #else
 #define MAYBE_EstablishAndTerminate DISABLED_EstablishAndTerminate
 #endif
 IN_PROC_BROWSER_TEST_F(BrowserGpuChannelHostFactoryTest,
                        MAYBE_EstablishAndTerminate) {
   DCHECK(!IsChannelEstablished());
   base::RunLoop run_loop;
-  GetFactory()->EstablishGpuChannel(kInitCause, run_loop.QuitClosure());
+  GetFactory()->EstablishGpuChannel(
+      kInitCause,
+      base::Bind(&OnEstablishedGpuChannel, run_loop.QuitClosure(), nullptr));
   GetFactory()->Terminate();
 
   // The callback should still trigger.
   run_loop.Run();
 }
 
 #if !defined(OS_ANDROID)
 // Test fails on Chromeos + Mac, flaky on Windows because UI Compositor
 // establishes a GPU channel.
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #define MAYBE_AlreadyEstablished AlreadyEstablished
 #else
 #define MAYBE_AlreadyEstablished DISABLED_AlreadyEstablished
 #endif
 IN_PROC_BROWSER_TEST_F(BrowserGpuChannelHostFactoryTest,
                        MAYBE_AlreadyEstablished) {
   DCHECK(!IsChannelEstablished());
   scoped_refptr<gpu::GpuChannelHost> gpu_channel =
       GetFactory()->EstablishGpuChannelSync(kInitCause);
 
   // Expect established callback immediately.
   bool event = false;
   GetFactory()->EstablishGpuChannel(
-      kInitCause,
-      base::Bind(&BrowserGpuChannelHostFactoryTest::Signal, &event));
+      kInitCause, base::Bind(&BrowserGpuChannelHostFactoryTest::Signal,
+                             base::Unretained(this), &event));
   EXPECT_TRUE(event);
   EXPECT_EQ(gpu_channel.get(), GetGpuChannel());
 }
 #endif
 
 // Test fails on Windows because GPU Channel set-up fails.
 #if !defined(OS_WIN)
 #define MAYBE_GrContextKeepsGpuChannelAlive GrContextKeepsGpuChannelAlive
 #else
 #define MAYBE_GrContextKeepsGpuChannelAlive \
@@ skipping 42 matching lines @@
   SkPaint greenFillPaint;
   greenFillPaint.setColor(SK_ColorGREEN);
   greenFillPaint.setStyle(SkPaint::kFill_Style);
   // Passes by not crashing
   surface->getCanvas()->drawRect(SkRect::MakeWH(100, 100), greenFillPaint);
 }
 
 // Test fails on Chromeos + Mac, flaky on Windows because UI Compositor
 // establishes a GPU channel.
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
-#define MAYBE_CrashAndRecover
+#define MAYBE_CrashAndRecover CrashAndRecover
 #else
 #define MAYBE_CrashAndRecover DISABLED_CrashAndRecover
 #endif
 IN_PROC_BROWSER_TEST_F(BrowserGpuChannelHostFactoryTest,
                        MAYBE_CrashAndRecover) {
   DCHECK(!IsChannelEstablished());
   EstablishAndWait();
   scoped_refptr<gpu::GpuChannelHost> host = GetGpuChannel();
 
   scoped_refptr<ContextProviderCommandBuffer> provider =
@@ skipping 10 matching lines @@
   shim->SimulateCrash();
   run_loop.Run();
 
   EXPECT_EQ(1, counter);
   EXPECT_FALSE(IsChannelEstablished());
   EstablishAndWait();
   EXPECT_TRUE(IsChannelEstablished());
 }
 
 }  // namespace content