test number of render passes

content/common/gpu/client/gl_helper_unittests.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 <stdio.h>
 #include <cmath>
 #include <string>
 #include <vector>
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/debug/trace_event.h"
 #include "base/file_util.h"
+#include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gl_helper_scaling.h"
 #include "content/public/test/unittest_test_suite.h"
 #include "content/test/content_test_suite.h"
 #include "gpu/config/gpu_util.h"
 #include "media/base/video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkTypes.h"
@@ skipping 39 matching lines @@
         context_.get(),
         helper_.get()));
   }
 
   virtual void TearDown() {
     helper_scaling_.reset(NULL);
     helper_.reset(NULL);
     context_.reset(NULL);
   }
 
+  void StartTracing(const std::string& filter) {
+    base::debug::TraceLog::GetInstance()->SetEnabled(
+        base::debug::CategoryFilter(filter),
+        base::debug::TraceLog::RECORD_UNTIL_FULL);
+  }
+
+  static void TraceDataCB(
+      const base::Callback<void()>& callback,
+      std::string* output,
+      const scoped_refptr<base::RefCountedString>& json_events_str,
+      bool has_more_events) {
+    if (output->size() > 1) {
+      output->append(",");
+    }
+    output->append(json_events_str->data());
+    if (!has_more_events) {
+      callback.Run();
+    }
+  }
+
+  // End tracing, return tracing data in a simple map
+  // of event name->counts.
+  void EndTracing(std::map<std::string, int> *event_counts) {
+    std::string json_data = "[";
+    base::debug::TraceLog::GetInstance()->SetDisabled();
+    base::RunLoop run_loop;
+    base::debug::TraceLog::GetInstance()->Flush(
+        base::Bind(&GLHelperTest::TraceDataCB,
+                   run_loop.QuitClosure(),
+                   base::Unretained(&json_data)));
+    run_loop.Run();
+    json_data.append("]");
+
+    scoped_ptr<Value> trace_data(base::JSONReader::Read(json_data));
+    ListValue* list;
+    CHECK(trace_data->GetAsList(&list));
+    for (size_t i = 0; i < list->GetSize(); i++) {
+      base::Value *item = NULL;
+      if (list->Get(i, &item)) {
+        base::DictionaryValue *dict;
+        CHECK(item->GetAsDictionary(&dict));
+        std::string name;
+        CHECK(dict->GetString("name", &name));
+        (*event_counts)[name]++;
+        VLOG(1) << "trace name: " << name;
+      }
+    }
+  }
+
   // Bicubic filter kernel function.
   static float Bicubic(float x) {
     const float a = -0.5;
     x = std::abs(x);
     float x2 = x * x;
     float x3 = x2 * x;
     if (x <= 1) {
       return (a + 2) * x3 - (a + 3) * x2 + 1;
     } else if (x < 2) {
       return a * x3 - 5 * a * x2 + 8 * a * x - 4 * a;
@@ skipping 698 matching lines @@
   // with reference implementation and compare to what gl_helper
   // returns.
   void TestYUVReadback(int xsize,
                        int ysize,
                        int output_xsize,
                        int output_ysize,
                        int xmargin,
                        int ymargin,
                        int test_pattern,
                        bool flip,
-                       bool use_mrt) {
+                       bool use_mrt,
+                       content::GLHelper::ScalerQuality quality) {
     WebGLId src_texture = context_->createTexture();
     SkBitmap input_pixels;
     input_pixels.setConfig(SkBitmap::kARGB_8888_Config, xsize, ysize);
     input_pixels.allocPixels();
     SkAutoLockPixels lock(input_pixels);
 
     for (int x = 0; x < xsize; ++x) {
       for (int y = 0; y < ysize; ++y) {
         switch (test_pattern) {
           case 0:  // Smooth test pattern
@@ skipping 40 matching lines @@
                                              "margin: %dx%d "
                                              "pattern: %d %s %s",
                                              xsize, ysize,
                                              output_xsize, output_ysize,
                                              xmargin, ymargin,
                                              test_pattern,
                                              flip ? "flip" : "noflip",
                                              flip ? "mrt" : "nomrt");
     scoped_ptr<ReadbackYUVInterface> yuv_reader(
         helper_->CreateReadbackPipelineYUV(
-            content::GLHelper::SCALER_QUALITY_GOOD,
+            quality,
             gfx::Size(xsize, ysize),
             gfx::Rect(0, 0, xsize, ysize),
             gfx::Size(output_xsize, output_ysize),
             gfx::Rect(xmargin, ymargin, xsize, ysize),
             flip,
             use_mrt));
 
     scoped_refptr<media::VideoFrame> output_frame =
         media::VideoFrame::CreateFrame(
             media::VideoFrame::YV12,
@@ skipping 274 matching lines @@
                    "8x1 -> 1x1 bilinear4 X\n");
   }
 
   scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> context_;
   gpu::ContextSupport* context_support_;
   scoped_ptr<content::GLHelper> helper_;
   scoped_ptr<content::GLHelperScaling> helper_scaling_;
   std::deque<GLHelperScaling::ScaleOp> x_ops_, y_ops_;
 };
 
+TEST_F(GLHelperTest, YUVReadbackOptTest) {
+  // This test uses the cb_command tracing events to detect how many
+  // scaling passes are actually performed by the YUV readback pipeline.
+  StartTracing(TRACE_DISABLED_BY_DEFAULT("cb_command"));
+
+  TestYUVReadback(
+      800, 400,
+      800, 400,
+      0,  0,
+      1,
+      false,
+      true,
+      content::GLHelper::SCALER_QUALITY_FAST);
+
+  std::map<std::string, int> event_counts;
+  EndTracing(&event_counts);
+  int draw_buffer_calls = event_counts["kDrawBuffersEXTImmediate"];
+  int draw_arrays_calls = event_counts["kDrawArrays"];
+  VLOG(1) << "Draw buffer calls: " << draw_buffer_calls;
+  VLOG(1) << "DrawArrays calls: " << draw_arrays_calls;
+
+  if (draw_buffer_calls) {
+    // When using MRT, the YUV readback code should only
+    // execute two draw arrays, and scaling should be integrated
+    // into those two calls since we are using the FAST scalign
+    // quality.
+    EXPECT_EQ(2, draw_arrays_calls);
+  } else {
+    // When not using MRT, there are three passes for the YUV,
+    // and one for the scaling.
+    EXPECT_EQ(4, draw_arrays_calls);
+  }
+}
+
 TEST_F(GLHelperTest, YUVReadbackTest) {
   int sizes[] = { 2, 4, 14 };
   for (int flip = 0; flip <= 1; flip++) {
     for (int use_mrt = 0; use_mrt <= 1; use_mrt++) {
       for (unsigned int x = 0; x < arraysize(sizes); x++) {
         for (unsigned int y = 0; y < arraysize(sizes); y++) {
           for (unsigned int ox = x; ox < arraysize(sizes); ox++) {
             for (unsigned int oy = y; oy < arraysize(sizes); oy++) {
               // If output is a subsection of the destination frame, (letterbox)
               // then try different variations of where the subsection goes.
               for (Margin xm = x < ox ? MarginLeft : MarginRight;
                    xm <= MarginRight;
                    xm = NextMargin(xm)) {
                 for (Margin ym = y < oy ? MarginLeft : MarginRight;
                      ym <= MarginRight;
                      ym = NextMargin(ym)) {
                   for (int pattern = 0; pattern < 3; pattern++) {
                     TestYUVReadback(
                         sizes[x],
                         sizes[y],
                         sizes[ox],
                         sizes[oy],
                         compute_margin(sizes[x], sizes[ox], xm),
                         compute_margin(sizes[y], sizes[oy], ym),
                         pattern,
                         flip == 1,
-                        use_mrt == 1);
+                        use_mrt == 1,
+                        content::GLHelper::SCALER_QUALITY_GOOD);
                     if (HasFailure()) {
                       return;
                     }
                   }
                 }
               }
             }
           }
         }
       }
     }
   }
 }
 
-
 // Per pixel tests, all sizes are small so that we can print
 // out the generated bitmaps.
 TEST_F(GLHelperTest, ScaleTest) {
   int sizes[] = {3, 6, 16};
   for (int flip = 0; flip <= 1; flip++) {
     for (size_t q = 0; q < arraysize(kQualities); q++) {
       for (int x = 0; x < 3; x++) {
         for (int y = 0; y < 3; y++) {
           for (int dst_x = 0; dst_x < 3; dst_x++) {
             for (int dst_y = 0; dst_y < 3; dst_y++) {
@@ skipping 91 matching lines @@
 #if defined(TOOLKIT_GTK)
   gfx::GtkInitFromCommandLine(*CommandLine::ForCurrentProcess());
 #endif
   gfx::GLSurface::InitializeOneOff();
   gpu::ApplyGpuDriverBugWorkarounds(CommandLine::ForCurrentProcess());
 
   content::UnitTestTestSuite runner(suite);
   base::MessageLoop message_loop;
   return runner.Run();
 }