Move H264Parser and H264BitReader to media/filters.

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/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/memory/scoped_vector.h"
 #include "base/process/process.h"
 #include "base/safe_numerics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "content/common/gpu/media/exynos_video_encode_accelerator.h"
-#include "content/common/gpu/media/h264_parser.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/filters/h264_parser.h"
 #include "media/video/video_encode_accelerator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using media::VideoEncodeAccelerator;
 
 namespace content {
 namespace {
 
 // Arbitrarily chosen to add some depth to the pipeline.
 const unsigned int kNumOutputBuffers = 4;
@@ skipping 144 matching lines @@
   bool save_to_file_;
   // Request a keyframe every keyframe_period_ frames.
   const unsigned int keyframe_period_;
   // Frame number for which we requested a keyframe.
   unsigned int keyframe_requested_at_;
   // True if we are asking encoder for a particular bitrate.
   bool force_bitrate_;
   // Byte size of the encoded stream (for bitrate calculation).
   size_t encoded_stream_size_;
 
-  content::H264Parser h264_parser_;
+  media::H264Parser h264_parser_;
 
   // All methods of this class should be run on the same thread.
   base::ThreadChecker thread_checker_;
 };
 
 VEAClient::VEAClient(const TestStream& test_stream,
                      ClientStateNotification<ClientState>* note,
                      bool save_to_file,
                      unsigned int keyframe_period,
                      bool force_bitrate)
@@ skipping 117 matching lines @@
   if (state_ == CS_FINISHED)
     return;
 
   encoded_stream_size_ += payload_size;
 
   h264_parser_.SetStream(static_cast<uint8*>(shm->memory()), payload_size);
 
   bool seen_idr_in_this_buffer = false;
 
   while (1) {
-    content::H264NALU nalu;
-    content::H264Parser::Result result;
+    media::H264NALU nalu;
+    media::H264Parser::Result result;
 
     result = h264_parser_.AdvanceToNextNALU(&nalu);
-    if (result == content::H264Parser::kEOStream)
+    if (result == media::H264Parser::kEOStream)
       break;
 
-    ASSERT_EQ(result, content::H264Parser::kOk);
+    ASSERT_EQ(result, media::H264Parser::kOk);
 
     switch (nalu.nal_unit_type) {
-      case content::H264NALU::kIDRSlice:
+      case media::H264NALU::kIDRSlice:
         ASSERT_TRUE(seen_sps_);
         ASSERT_TRUE(seen_pps_);
         seen_idr_ = seen_idr_in_this_buffer = true;
         // Got keyframe, reset keyframe detection regardless of whether we
         // got a frame in time or not.
         keyframe_requested_at_ = kMaxFrameNum;
         // fallthrough
-      case content::H264NALU::kNonIDRSlice:
+      case media::H264NALU::kNonIDRSlice:
         ASSERT_TRUE(seen_idr_);
         ++num_encoded_slices_;
 
         // Because the keyframe behavior requirements are loose, we give
         // the encoder more freedom here. It could either deliver a keyframe
         // immediately after we requested it, which could be for a frame number
         // before the one we requested it for (if the keyframe request
         // is asynchronous, i.e. not bound to any concrete frame, and because
         // the pipeline can be deeper that one frame), at that frame, or after.
         // So the only constraints we put here is that we get a keyframe not
         // earlier than we requested one (in time), and not later than
         // kMaxKeyframeDelay frames after the frame for which we requested
         // it comes back as encoded slice.
         EXPECT_LE(num_encoded_slices_,
                   keyframe_requested_at_ + kMaxKeyframeDelay);
         break;
-      case content::H264NALU::kSPS:
+      case media::H264NALU::kSPS:
         seen_sps_ = true;
         break;
-      case content::H264NALU::kPPS:
+      case media::H264NALU::kPPS:
         ASSERT_TRUE(seen_sps_);
         seen_pps_ = true;
         break;
       default:
         break;
     }
 
     if (num_encoded_slices_ == num_frames_in_stream_) {
       ASSERT_EQ(state_, CS_FINISHING);
       ChecksAtFinish();
@@ skipping 221 matching lines @@
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
 
   return RUN_ALL_TESTS();
 }