Revert 158707 - Enable by default:

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/stringprintf.h"
 #include "base/test/trace_event_analyzer.h"
@@ skipping 23 matching lines @@
 #endif
 
 using content::GpuDataManager;
 using content::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";
+typedef uint32 GpuResultFlags;
+#define EXPECT_NO_GPU_SWAP_BUFFERS    GpuResultFlags(1<<0)
+// Expect a SwapBuffers to occur (see gles2_cmd_decoder.cc).
+#define EXPECT_GPU_SWAP_BUFFERS       GpuResultFlags(1<<1)
 
 class GpuFeatureTest : public InProcessBrowserTest {
  public:
   GpuFeatureTest() : trace_categories_("test_gpu"), gpu_enabled_(false) {}
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() {
     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) {
     // Do not use mesa if real GPU is required.
     if (!command_line->HasSwitch(switches::kUseGpuInTests)) {
 #if !defined(OS_MACOSX)
       CHECK(test_launcher_utils::OverrideGLImplementation(
@@ skipping 39 matching lines @@
           browser(), net::FilePathToFileURL(test_path));
     }
 
     std::string result;
     // Wait for message indicating the test has finished running.
     ASSERT_TRUE(message_queue.WaitForMessage(&result));
     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 FilePath& url,
-                    const char* event_name = NULL,
-                    bool event_expected = false) {
+  void RunTest(const FilePath& url, GpuResultFlags expectations) {
 #if defined(OS_LINUX) && !defined(NDEBUG)
     // Bypass tests on GPU Linux Debug bots.
     if (gpu_enabled_)
       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(trace_categories_));
 
     // Have to use a new tab for the blacklist to work.
     RunTest(url, NULL, true);
 
     ASSERT_TRUE(tracing::EndTracing(&trace_events_json_));
 
     analyzer_.reset(TraceAnalyzer::Create(trace_events_json_));
     analyzer_->AssociateBeginEndEvents();
     TraceEventVector events;
 
-    if (!event_name)
-      return;
+    if (expectations & EXPECT_NO_GPU_SWAP_BUFFERS) {
+      EXPECT_EQ(analyzer_->FindEvents(Query::EventNameIs("SwapBuffers"),
+                                      &events), size_t(0));
+    }
 
-    size_t event_count =
-        analyzer_->FindEvents(Query::EventNameIs(event_name), &events);
-
-    if (event_expected)
-      EXPECT_GT(event_count, 0U);
-    else
-      EXPECT_EQ(event_count, 0U);
+    // Check for swap buffers if expected:
+    if (expectations & EXPECT_GPU_SWAP_BUFFERS) {
+      EXPECT_GT(analyzer_->FindEvents(Query::EventNameIs("SwapBuffers"),
+                                      &events), size_t(0));
+    }
   }
 
   // Trigger a resize of the chrome window, and use tracing to wait for the
   // given |wait_event|.
   bool ResizeAndWait(const gfx::Rect& new_bounds,
                      const char* trace_categories,
                      const char* wait_category,
                      const char* wait_event) {
     if (!tracing::BeginTracingWithWatch(trace_categories, wait_category,
                                         wait_event, 1))
@@ skipping 15 matching lines @@
   std::string trace_events_json_;
   bool gpu_enabled_;
 };
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, AcceleratedCompositingAllowed) {
   GpuFeatureType type =
       GpuDataManager::GetInstance()->GetBlacklistedFeatures();
   EXPECT_EQ(type, 0);
 
   const FilePath url(FILE_PATH_LITERAL("feature_compositing.html"));
-  RunEventTest(url, kSwapBuffersEvent, true);
+  RunTest(url, EXPECT_GPU_SWAP_BUFFERS);
 }
 
 // Flash Stage3D may be blacklisted for other reasons on XP, so ignore it.
 GpuFeatureType IgnoreGpuFeatures(GpuFeatureType type) {
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return static_cast<GpuFeatureType>(type &
         ~content::GPU_FEATURE_TYPE_FLASH_STAGE3D);
 #endif
   return type;
 }
 
-class AcceleratedCompositingBlockedTest : public GpuFeatureTest {
- public:
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
-    GpuFeatureTest::SetUpInProcessBrowserTestFixture();
-    const std::string json_blacklist =
+IN_PROC_BROWSER_TEST_F(GpuFeatureTest, AcceleratedCompositingBlocked) {
+  const std::string json_blacklist =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"1.0\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"blacklist\": [\n"
       "        \"accelerated_compositing\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-    SetupBlacklist(json_blacklist);
-  }
-};
-
-IN_PROC_BROWSER_TEST_F(AcceleratedCompositingBlockedTest,
-    AcceleratedCompositingBlocked) {
+  SetupBlacklist(json_blacklist);
   GpuFeatureType type =
       GpuDataManager::GetInstance()->GetBlacklistedFeatures();
   type = IgnoreGpuFeatures(type);
-
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING);
 
   const FilePath url(FILE_PATH_LITERAL("feature_compositing.html"));
-  RunEventTest(url, kSwapBuffersEvent, false);
+  RunTest(url, EXPECT_NO_GPU_SWAP_BUFFERS);
 }
 
 class AcceleratedCompositingTest : public GpuFeatureTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) {
     GpuFeatureTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(AcceleratedCompositingTest,
                        AcceleratedCompositingDisabled) {
   const FilePath url(FILE_PATH_LITERAL("feature_compositing.html"));
-  RunEventTest(url, kSwapBuffersEvent, false);
+  RunTest(url, EXPECT_NO_GPU_SWAP_BUFFERS);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, WebGLAllowed) {
   GpuFeatureType type =
       GpuDataManager::GetInstance()->GetBlacklistedFeatures();
   EXPECT_EQ(type, 0);
 
   const FilePath url(FILE_PATH_LITERAL("feature_webgl.html"));
-  RunEventTest(url, kWebGLCreationEvent, true);
+  RunTest(url, EXPECT_GPU_SWAP_BUFFERS);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, WebGLBlocked) {
   const std::string json_blacklist =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"1.0\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
   SetupBlacklist(json_blacklist);
   GpuFeatureType type =
       GpuDataManager::GetInstance()->GetBlacklistedFeatures();
   type = IgnoreGpuFeatures(type);
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 
   const FilePath url(FILE_PATH_LITERAL("feature_webgl.html"));
-  RunEventTest(url, kWebGLCreationEvent, false);
+  RunTest(url, EXPECT_NO_GPU_SWAP_BUFFERS);
 }
 
 class WebGLTest : public GpuFeatureTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) {
     GpuFeatureTest::SetUpCommandLine(command_line);
 #if !defined(OS_ANDROID)
     // On Android, WebGL is disabled by default
     command_line->AppendSwitch(switches::kDisableExperimentalWebGL);
 #endif
   }
 };
 
 IN_PROC_BROWSER_TEST_F(WebGLTest, WebGLDisabled) {
   const FilePath url(FILE_PATH_LITERAL("feature_webgl.html"));
-  RunEventTest(url, kWebGLCreationEvent, false);
+  RunTest(url, EXPECT_NO_GPU_SWAP_BUFFERS);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, MultisamplingAllowed) {
   GpuFeatureType type =
       GpuDataManager::GetInstance()->GetBlacklistedFeatures();
   EXPECT_EQ(type, 0);
 
   // Multisampling is not supported if running on top of osmesa.
   std::string use_gl = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kUseGL);
@@ skipping 60 matching lines @@
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, Canvas2DAllowed) {
   // Accelerated canvas 2D is not supported on XP.
   if (GPUTestBotConfig::CurrentConfigMatches("XP"))
     return;
 
   GpuFeatureType type =
       GpuDataManager::GetInstance()->GetBlacklistedFeatures();
   EXPECT_EQ(type, 0);
 
   const FilePath url(FILE_PATH_LITERAL("feature_canvas2d.html"));
-  RunEventTest(url, kAcceleratedCanvasCreationEvent, true);
+  RunTest(url, EXPECT_GPU_SWAP_BUFFERS);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, Canvas2DBlocked) {
   const std::string json_blacklist =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"1.0\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"blacklist\": [\n"
       "        \"accelerated_2d_canvas\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
   SetupBlacklist(json_blacklist);
   GpuFeatureType type =
       GpuDataManager::GetInstance()->GetBlacklistedFeatures();
   type = IgnoreGpuFeatures(type);
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS);
 
   const FilePath url(FILE_PATH_LITERAL("feature_canvas2d.html"));
-  RunEventTest(url, kAcceleratedCanvasCreationEvent, false);
+  RunTest(url, EXPECT_NO_GPU_SWAP_BUFFERS);
 }
 
 class Canvas2DDisabledTest : public GpuFeatureTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) {
     GpuFeatureTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(Canvas2DDisabledTest, Canvas2DDisabled) {
   const FilePath url(FILE_PATH_LITERAL("feature_canvas2d.html"));
-  RunEventTest(url, kAcceleratedCanvasCreationEvent, false);
+  RunTest(url, EXPECT_NO_GPU_SWAP_BUFFERS);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest,
                        CanOpenPopupAndRenderWithWebGLCanvas) {
   const FilePath url(FILE_PATH_LITERAL("webgl_popup.html"));
   RunTest(url, "\"SUCCESS\"", false);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, CanOpenPopupAndRenderWith2DCanvas) {
   const FilePath url(FILE_PATH_LITERAL("canvas_popup.html"));
   RunTest(url, "\"SUCCESS\"", false);
 }
 
 class ThreadedCompositorTest : public GpuFeatureTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) {
     GpuFeatureTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kEnableThreadedCompositing);
   }
 };
 
 // disabled in http://crbug.com/123503
 IN_PROC_BROWSER_TEST_F(ThreadedCompositorTest, ThreadedCompositor) {
   const FilePath url(FILE_PATH_LITERAL("feature_compositing.html"));
-  RunEventTest(url, kSwapBuffersEvent, true);
+  RunTest(url, EXPECT_GPU_SWAP_BUFFERS);
 }
 
 IN_PROC_BROWSER_TEST_F(GpuFeatureTest, RafNoDamage) {
   trace_categories_ = "-test_*";
   const FilePath url(FILE_PATH_LITERAL("feature_raf_no_damage.html"));
-  RunEventTest(url);
+  RunTest(url, GpuResultFlags(0));
 
   if (!analyzer_.get())
     return;
 
   // Search for matching name on begin event or async_begin event (any begin).
   Query query_raf =
       (Query::EventPhaseIs(TRACE_EVENT_PHASE_BEGIN) ||
        Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_BEGIN)) &&
       Query::EventNameIs("___RafWithNoDamage___");
   TraceEventVector events;
@@ skipping 85 matching lines @@
           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