Rewrite std::string("") to std::string(), Linux edition.

media/webm/webm_cluster_parser_unittest.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 <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/decrypt_config.h"
 #include "media/webm/cluster_builder.h"
@@ skipping 185 matching lines @@
                         WebMClusterParser::BufferQueue* dest) {
   for (WebMClusterParser::BufferQueue::const_iterator itr = src.begin();
        itr != src.end(); ++itr) {
     dest->push_back(*itr);
   }
 }
 
 class WebMClusterParserTest : public testing::Test {
  public:
   WebMClusterParserTest()
-      : parser_(new WebMClusterParser(
-          kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
-          std::set<int>(),
-          std::set<int64>(),
-          "", "",
-          LogCB())) {
-  }
+      : parser_(new WebMClusterParser(kTimecodeScale,
+                                      kAudioTrackNum,
+                                      kVideoTrackNum,
+                                      std::set<int>(),
+                                      std::set<int64>(),
+                                      std::string(),
+                                      std::string(),
+                                      LogCB())) {}
 
  protected:
   scoped_ptr<WebMClusterParser> parser_;
 };
 
 TEST_F(WebMClusterParserTest, TestReset) {
   InSequence s;
 
   int block_count = arraysize(kDefaultBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kDefaultBlockInfo, block_count));
@@ skipping 104 matching lines @@
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, IgnoredTracks) {
   std::set<int64> ignored_tracks;
   ignored_tracks.insert(kTextTrackNum);
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
-      std::set<int>(),
-      ignored_tracks, "", "",
-      LogCB()));
+  parser_.reset(new WebMClusterParser(kTimecodeScale,
+                                      kAudioTrackNum,
+                                      kVideoTrackNum,
+                                      std::set<int>(),
+                                      ignored_tracks,
+                                      std::string(),
+                                      std::string(),
+                                      LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kAudioTrackNum, 0,  23, true },
     { kAudioTrackNum, 23, 23, true },
     { kVideoTrackNum, 33, 33, true },
     { kTextTrackNum,  33, 99, true },
     { kAudioTrackNum, 46, 23, true },
     { kVideoTrackNum, 67, 33, true },
   };
   int input_block_count = arraysize(kInputBlockInfo);
@@ skipping 12 matching lines @@
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kOutputBlockInfo, output_block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseTextTracks) {
   std::set<int> text_tracks;
   text_tracks.insert(kTextTrackNum);
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
-      text_tracks,
-      std::set<int64>(), "", "",
-      LogCB()));
+  parser_.reset(new WebMClusterParser(kTimecodeScale,
+                                      kAudioTrackNum,
+                                      kVideoTrackNum,
+                                      text_tracks,
+                                      std::set<int64>(),
+                                      std::string(),
+                                      std::string(),
+                                      LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kAudioTrackNum, 0,  23, true },
     { kAudioTrackNum, 23, 23, true },
     { kVideoTrackNum, 33, 33, true },
     { kTextTrackNum,  33, 42, false },
     { kAudioTrackNum, 46, 23, true },
     { kTextTrackNum, 55, 44, false },
     { kVideoTrackNum, 67, 33, true },
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   scoped_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kInputBlockInfo, input_block_count));
 }
 
 TEST_F(WebMClusterParserTest, TextTracksSimpleBlock) {
   std::set<int> text_tracks;
   text_tracks.insert(kTextTrackNum);
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
-      text_tracks,
-      std::set<int64>(), "", "",
-      LogCB()));
+  parser_.reset(new WebMClusterParser(kTimecodeScale,
+                                      kAudioTrackNum,
+                                      kVideoTrackNum,
+                                      text_tracks,
+                                      std::set<int64>(),
+                                      std::string(),
+                                      std::string(),
+                                      LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kTextTrackNum,  33, 42, true },
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   scoped_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_LT(result, 0);
 }
 
 TEST_F(WebMClusterParserTest, ParseMultipleTextTracks) {
   typedef std::set<int> TextTrackSet;
   TextTrackSet text_tracks;
 
   const int kSubtitleTextTrackNum = kTextTrackNum;
   const int kCaptionTextTrackNum = kTextTrackNum + 1;
 
   text_tracks.insert(kSubtitleTextTrackNum);
   text_tracks.insert(kCaptionTextTrackNum);
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
-      text_tracks,
-      std::set<int64>(), "", "",
-      LogCB()));
+  parser_.reset(new WebMClusterParser(kTimecodeScale,
+                                      kAudioTrackNum,
+                                      kVideoTrackNum,
+                                      text_tracks,
+                                      std::set<int64>(),
+                                      std::string(),
+                                      std::string(),
+                                      LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kAudioTrackNum, 0,  23, true },
     { kAudioTrackNum, 23, 23, true },
     { kVideoTrackNum, 33, 33, true },
     { kSubtitleTextTrackNum,  33, 42, false },
     { kAudioTrackNum, 46, 23, true },
     { kCaptionTextTrackNum, 55, 44, false },
     { kVideoTrackNum, 67, 33, true },
     { kSubtitleTextTrackNum,  67, 33, false },
@@ skipping 17 matching lines @@
         text_tracks.find(text_track_num);
     ASSERT_TRUE(find_result != text_tracks.end());
     ASSERT_TRUE(VerifyTextBuffers(parser_, kInputBlockInfo, input_block_count,
                                   text_track_num, *text_buffers));
   }
 }
 
 TEST_F(WebMClusterParserTest, ParseEncryptedBlock) {
   scoped_ptr<Cluster> cluster(CreateEncryptedCluster(sizeof(kEncryptedFrame)));
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
-      std::set<int>(),
-      std::set<int64>(), "", "video_key_id",
-      LogCB()));
+  parser_.reset(new WebMClusterParser(kTimecodeScale,
+                                      kAudioTrackNum,
+                                      kVideoTrackNum,
+                                      std::set<int>(),
+                                      std::set<int64>(),
+                                      std::string(),
+                                      "video_key_id",
+                                      LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_EQ(1UL, parser_->video_buffers().size());
   scoped_refptr<StreamParserBuffer> buffer = parser_->video_buffers()[0];
   EXPECT_TRUE(VerifyEncryptedBuffer(buffer));
 }
 
 TEST_F(WebMClusterParserTest, ParseBadEncryptedBlock) {
   scoped_ptr<Cluster> cluster(
       CreateEncryptedCluster(sizeof(kEncryptedFrame) - 1));
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kVideoTrackNum,
-      std::set<int>(),
-      std::set<int64>(), "", "video_key_id",
-      LogCB()));
+  parser_.reset(new WebMClusterParser(kTimecodeScale,
+                                      kAudioTrackNum,
+                                      kVideoTrackNum,
+                                      std::set<int>(),
+                                      std::set<int64>(),
+                                      std::string(),
+                                      "video_key_id",
+                                      LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
 
 }  // namespace media