Revert of Cast:Adding cast_transport_config and cleaning up

media/cast/video_sender/external_video_encoder_unittest.cc

 // Copyright 2014 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 <vector>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
@@ skipping 20 matching lines @@
   void SetExpectedResult(bool expected_key_frame,
                          uint8 expected_frame_id,
                          uint8 expected_last_referenced_frame_id,
                          const base::TimeTicks& expected_capture_time) {
     expected_key_frame_ = expected_key_frame;
     expected_frame_id_ = expected_frame_id;
     expected_last_referenced_frame_id_ = expected_last_referenced_frame_id;
     expected_capture_time_ = expected_capture_time;
   }
 
-  void DeliverEncodedVideoFrame(
-      scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
-      const base::TimeTicks& capture_time) {
+  void DeliverEncodedVideoFrame(scoped_ptr<EncodedVideoFrame> encoded_frame,
+                                const base::TimeTicks& capture_time) {
     EXPECT_EQ(expected_key_frame_, encoded_frame->key_frame);
     EXPECT_EQ(expected_frame_id_, encoded_frame->frame_id);
     EXPECT_EQ(expected_last_referenced_frame_id_,
               encoded_frame->last_referenced_frame_id);
     EXPECT_EQ(expected_capture_time_, capture_time);
   }
 
  protected:
   virtual ~TestVideoEncoderCallback() {}
 
@@ skipping 18 matching lines @@
     video_config_.use_external_encoder = true;
     video_config_.width = 320;
     video_config_.height = 240;
     video_config_.max_bitrate = 5000000;
     video_config_.min_bitrate = 1000000;
     video_config_.start_bitrate = 2000000;
     video_config_.max_qp = 56;
     video_config_.min_qp = 0;
     video_config_.max_frame_rate = 30;
     video_config_.max_number_of_video_buffers_used = 3;
-    video_config_.codec = transport::kVp8;
+    video_config_.codec = kVp8;
     gfx::Size size(video_config_.width, video_config_.height);
     video_frame_ =  media::VideoFrame::CreateFrame(VideoFrame::I420,
         size, gfx::Rect(size), size, base::TimeDelta());
     PopulateVideoFrame(video_frame_, 123);
   }
 
   virtual ~ExternalVideoEncoderTest() {}
 
   virtual void SetUp() {
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
-        task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
+        task_runner_, task_runner_, task_runner_, task_runner_,
         GetDefaultCastLoggingConfig());
     video_encoder_.reset(new ExternalVideoEncoder(
         cast_environment_,
         video_config_,
         new test::FakeGpuVideoAcceleratorFactories(task_runner_)));
   }
 
   base::SimpleTestTickClock testing_clock_;
   scoped_refptr<TestVideoEncoderCallback> test_video_encoder_callback_;
   VideoSenderConfig video_config_;
@@ skipping 22 matching lines @@
     test_video_encoder_callback_->SetExpectedResult(false, i + 1, i,
                                                     capture_time);
     EXPECT_TRUE(video_encoder_->EncodeVideoFrame(video_frame_, capture_time,
                                                  frame_encoded_callback));
     task_runner_->RunTasks();
   }
 }
 
 }  // namespace cast
 }  // namespace media