Clean up compositor initialization/destruction.

chrome/test/gpu/gpu_feature_browsertest.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 "base/command_line.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/trace_event_analyzer.h"
 #include "base/version.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
-#include "chrome/test/base/test_launcher_utils.h"
 #include "chrome/test/base/tracing.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "gpu/config/gpu_feature_type.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/config/gpu_test_config.h"
 #include "net/base/net_util.h"
-#include "ui/compositor/compositor_setup.h"
-#include "ui/gl/gl_switches.h"
+#include "ui/gl/gl_implementation.h"
 
 #if defined(OS_MACOSX)
 #include "ui/gl/io_surface_support_mac.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using content::GpuDataManager;
 using gpu::GpuFeatureType;
 using trace_analyzer::Query;
 using trace_analyzer::TraceAnalyzer;
 using trace_analyzer::TraceEventVector;
 
 namespace {
 
 const char kSwapBuffersEvent[] = "SwapBuffers";
 const char kAcceleratedCanvasCreationEvent[] = "Canvas2DLayerBridgeCreation";
 const char kWebGLCreationEvent[] = "DrawingBufferCreation";
 
 class GpuFeatureTest : public InProcessBrowserTest {
  public:
-  GpuFeatureTest() : category_patterns_("test_gpu"), gpu_enabled_(false) {}
+  GpuFeatureTest() : category_patterns_("test_gpu") {}
+
+  virtual void SetUp() OVERRIDE {
+    // We expect to use real GL contexts for these tests.
+    UseRealGLContexts();
+
+    InProcessBrowserTest::SetUp();
+  }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     base::FilePath test_dir;
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir));
     gpu_test_dir_ = test_dir.AppendASCII("gpu");
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
-    // Do not use mesa if real GPU is required.
-    if (!command_line->HasSwitch(switches::kUseGpuInTests)) {
-#if !defined(OS_MACOSX)
-      CHECK(test_launcher_utils::OverrideGLImplementation(
-          command_line, gfx::kGLImplementationOSMesaName)) <<
-          "kUseGL must not be set by test framework code!";
-#endif
-    } else {
-      gpu_enabled_ = true;
-    }
     command_line->AppendSwitch(switches::kDisablePopupBlocking);
-    ui::DisableTestCompositor();
     command_line->AppendSwitchASCII(switches::kWindowSize, "400,300");
   }
 
   void SetupBlacklist(const std::string& json_blacklist) {
     gpu::GPUInfo gpu_info;
     GpuDataManager::GetInstance()->InitializeForTesting(
         json_blacklist, gpu_info);
   }
 
   // If expected_reply is NULL, we don't check the reply content.
   void RunTest(const base::FilePath& url,
                const char* expected_reply,
                bool new_tab) {
 #if defined(OS_LINUX) && !defined(NDEBUG)
     // Bypass tests on GPU Linux Debug bots.
-    if (gpu_enabled_)
+    if (gfx::GetGLImplementation() != gfx::kGLImplementationOSMesaGL)
       return;
 #endif
 
     base::FilePath test_path;
     test_path = gpu_test_dir_.Append(url);
     ASSERT_TRUE(base::PathExists(test_path))
         << "Missing test file: " << test_path.value();
 
     content::DOMMessageQueue message_queue;
     if (new_tab) {
@@ skipping 11 matching lines @@
     if (expected_reply)
       EXPECT_STREQ(expected_reply, result.c_str());
   }
 
   // Open the URL and check the trace stream for the given event.
   void RunEventTest(const base::FilePath& url,
                     const char* event_name = NULL,
                     bool event_expected = false) {
 #if defined(OS_LINUX) && !defined(NDEBUG)
     // Bypass tests on GPU Linux Debug bots.
-    if (gpu_enabled_)
+    if (gfx::GetGLImplementation() != gfx::kGLImplementationOSMesaGL)
       return;
 #endif
 #if defined(OS_MACOSX)
     // Bypass tests on Mac OSX 10.5 bots (IOSurfaceSupport is now required).
     if (!IOSurfaceSupport::Initialize())
       return;
 #endif
 
     ASSERT_TRUE(tracing::BeginTracing(category_patterns_));
 
@@ skipping 35 matching lines @@
     analyzer_.reset(TraceAnalyzer::Create(trace_events_json_));
     analyzer_->AssociateBeginEndEvents();
     return true;
   }
 
  protected:
   base::FilePath gpu_test_dir_;
   scoped_ptr<TraceAnalyzer> analyzer_;
   std::string category_patterns_;
   std::string trace_events_json_;
-  bool gpu_enabled_;
 };
 
 #if defined(OS_WIN) || defined(ADDRESS_SANITIZER)
 // This test is flaky on Windows. http://crbug.com/177113
 // Also fails under AddressSanitizer. http://crbug.com/185178
 #define MAYBE_AcceleratedCompositingAllowed DISABLED_AcceleratedCompositingAllowed
 #else
 #define MAYBE_AcceleratedCompositingAllowed AcceleratedCompositingAllowed
 #endif
 
@@ skipping 114 matching lines @@
 IN_PROC_BROWSER_TEST_F(WebGLTest, WebGLDisabled) {
   const base::FilePath url(FILE_PATH_LITERAL("feature_webgl.html"));
   RunEventTest(url, kWebGLCreationEvent, false);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, MultisamplingAllowed) {
   EXPECT_FALSE(GpuDataManager::GetInstance()->IsFeatureBlacklisted(
       gpu::GPU_FEATURE_TYPE_MULTISAMPLING));
 
   // Multisampling is not supported if running on top of osmesa.
-  std::string use_gl = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-      switches::kUseGL);
-  if (use_gl == gfx::kGLImplementationOSMesaName)
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationOSMesaGL)
     return;
 
   // Linux Intel uses mesa driver, where multisampling is not supported.
   // Multisampling is also not supported on virtualized mac os.
   std::vector<std::string> configs;
   configs.push_back("LINUX INTEL");
   configs.push_back("MAC VMWARE");
   if (gpu::GPUTestBotConfig::CurrentConfigMatches(configs))
     return;
 
@@ skipping 227 matching lines @@
       LOG(INFO) <<
           base::StringPrintf(
               "%d (resize offset %d): IOSurface width %d -> %d; Creates %d "
               "Expected %d", offset_i, offsets[offset_i],
               old_width, new_width, num_creates, expected_creates);
     }
   }
 }
 #endif
 
-}  // namespace anonymous
+}  // namespace