vea_unittest: Add --output_log option

content/common/gpu/media/video_encode_accelerator_unittest.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/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/memory/scoped_vector.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/h264_parser.h"
 #include "media/video/fake_video_encode_accelerator.h"
 #include "media/video/video_encode_accelerator.h"
@@ skipping 320 matching lines @@
     }
 
     if (fields.size() >= 9 && !fields[8].empty()) {
       CHECK(base::StringToUint(fields[8],
                                &test_stream->requested_subsequent_framerate));
     }
     test_streams->push_back(test_stream);
   }
 }
 
+// Basic test environment shared across multiple test cases. We only need to
+// setup it once for all test cases.
+// It helps
+// - maintain test stream data and other test settings.
+// - clean up temporary aligned files.
+// - output log to file.
+class VideoEncodeAcceleratorTestEnvironment : public ::testing::Environment {
+ public:
+  VideoEncodeAcceleratorTestEnvironment(
+      scoped_ptr<base::FilePath::StringType> data,
+      const base::FilePath& log_path,
+      bool run_at_fps)
+      : run_at_fps_(run_at_fps),
+        test_stream_data_(data.Pass()),
+        log_path_(log_path) {}
+
+  virtual void SetUp() {
+    if (!log_path_.empty()) {
+      log_file_.reset(new base::File(
+          log_path_, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE));
+      CHECK(log_file_->IsValid());
+    }
+    ParseAndReadTestStreamData(*test_stream_data_, &test_streams_);
+  }
+
+  virtual void TearDown() {
+    for (size_t i = 0; i < test_streams_.size(); i++) {
+      base::DeleteFile(test_streams_[i]->aligned_in_file, false);
+    }
+    log_file_.reset();
+  }
+
+  // Log one entry of machine-readable data to file.
+  // The log has one data entry per line in the format of "<key>: <value>".
+  void LogToFile(const std::string& key, const std::string& value) {
+    if (log_file_) {
+      std::string s =
+          base::StringPrintf("%s: %s\n", key.c_str(), value.c_str());
+      log_file_->WriteAtCurrentPos(s.data(), s.length());
+    }
+  }
+
+  ScopedVector<TestStream> test_streams_;
+  bool run_at_fps_;
+
+ private:
+  scoped_ptr<base::FilePath::StringType> test_stream_data_;
+  base::FilePath log_path_;
+  scoped_ptr<base::File> log_file_;
+};
+
 enum ClientState {
   CS_CREATED,
   CS_ENCODER_SET,
   CS_INITIALIZED,
   CS_ENCODING,
   CS_FINISHED,
   CS_ERROR,
 };
 
 // Performs basic, codec-specific sanity checks on the stream buffers passed
@@ skipping 761 matching lines @@
     SetState(CS_FINISHED);
     return false;
   }
 
   return true;
 }
 
 void VEAClient::VerifyPerf() {
   double measured_fps = frames_per_second();
   LOG(INFO) << "Measured encoder FPS: " << measured_fps;
+  g_env->LogToFile("Measured encoder FPS",
+                   base::StringPrintf("%.3f", measured_fps));
   if (test_perf_)
     EXPECT_GE(measured_fps, kMinPerfFPS);
 }
 
 void VEAClient::VerifyStreamProperties() {
   CHECK_GT(num_frames_since_last_check_, 0UL);
   CHECK_GT(encoded_stream_size_since_last_check_, 0UL);
   unsigned int bitrate = encoded_stream_size_since_last_check_ * 8 *
                          current_framerate_ / num_frames_since_last_check_;
   DVLOG(1) << "Current chunk's bitrate: " << bitrate
@@ skipping 47 matching lines @@
   IvfFrameHeader header;
 
   memset(&header, 0, sizeof(header));
   header.frame_size = base::ByteSwapToLE32(frame_size);
   header.timestamp = base::ByteSwapToLE64(frame_index);
   EXPECT_TRUE(base::AppendToFile(
       base::FilePath::FromUTF8Unsafe(test_stream_->out_filename),
       reinterpret_cast<char*>(&header), sizeof(header)));
 }
 
-// Setup test stream data and delete temporary aligned files at the beginning
-// and end of unittest. We only need to setup once for all test cases.
-class VideoEncodeAcceleratorTestEnvironment : public ::testing::Environment {
- public:
-  VideoEncodeAcceleratorTestEnvironment(
-      scoped_ptr<base::FilePath::StringType> data,
-      bool run_at_fps) {
-    test_stream_data_ = data.Pass();
-    run_at_fps_ = run_at_fps;
-  }
-
-  virtual void SetUp() {
-    ParseAndReadTestStreamData(*test_stream_data_, &test_streams_);
-  }
-
-  virtual void TearDown() {
-    for (size_t i = 0; i < test_streams_.size(); i++) {
-      base::DeleteFile(test_streams_[i]->aligned_in_file, false);
-    }
-  }
-
-  ScopedVector<TestStream> test_streams_;
-  bool run_at_fps_;
-
- private:
-  scoped_ptr<base::FilePath::StringType> test_stream_data_;
-};
-
 // Test parameters:
 // - Number of concurrent encoders. The value takes effect when there is only
 //   one input stream; otherwise, one encoder per input stream will be
 //   instantiated.
 // - If true, save output to file (provided an output filename was supplied).
 // - Force a keyframe every n frames.
 // - Force bitrate; the actual required value is provided as a property
 //   of the input stream, because it depends on stream type/resolution/etc.
 // - If true, measure performance.
 // - If true, switch bitrate mid-stream.
@@ skipping 130 matching lines @@
 
   // Needed to enable DVLOG through --vmodule.
   logging::LoggingSettings settings;
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
   CHECK(logging::InitLogging(settings));
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   DCHECK(cmd_line);
 
   bool run_at_fps = false;
+  base::FilePath log_path;
+
   base::CommandLine::SwitchMap switches = cmd_line->GetSwitches();
   for (base::CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end();
        ++it) {
     if (it->first == "test_stream_data") {
       test_stream_data->assign(it->second.c_str());
       continue;
     }
+    // Output machine-readable logs with fixed formats to a file.
+    if (it->first == "output_log") {
+      log_path = base::FilePath(
+          base::FilePath::StringType(it->second.begin(), it->second.end()));
+      continue;
+    }
     if (it->first == "num_frames_to_encode") {
       std::string input(it->second.begin(), it->second.end());
       CHECK(base::StringToInt(input, &content::g_num_frames_to_encode));
       continue;
     }
     if (it->first == "fake_encoder") {
       content::g_fake_encoder = true;
       continue;
     }
     if (it->first == "run_at_fps") {
       run_at_fps = true;
       continue;
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     if (it->first == "ozone-platform" || it->first == "ozone-use-surfaceless")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
-                  test_stream_data.Pass(), run_at_fps)));
+                  test_stream_data.Pass(), log_path, run_at_fps)));
 
   return RUN_ALL_TESTS();
 }