Revert of Cast:Adding cast_transport_config and cleaning up

media/cast/video_sender/external_video_encoder.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 "media/cast/video_sender/external_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/transport/cast_transport_config.h"
 #include "media/video/video_encode_accelerator.h"
 
 namespace {
   // We allocate more input buffers than what is asked for by
   // RequireBitstreamBuffers() due to potential threading timing.
   static const int kInputBufferExtraCount = 1;
   static const int kOutputBufferCount = 3;
 
   void LogFrameEncodedEvent(
       const base::TimeTicks& now,
@@ skipping 46 matching lines @@
     DCHECK(encoder_task_runner_);
 
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
     video_encode_accelerator_ =
         gpu_factories_->CreateVideoEncodeAccelerator(this).Pass();
     if (!video_encode_accelerator_) return;
 
     VideoCodecProfile output_profile = media::VIDEO_CODEC_PROFILE_UNKNOWN;
     switch (video_config.codec) {
-      case transport::kVp8:
+      case kVp8:
         output_profile = media::VP8PROFILE_MAIN;
         break;
-      case transport::kH264:
+      case kH264:
         output_profile = media::H264PROFILE_MAIN;
         break;
     }
     codec_ = video_config.codec;
     max_frame_rate_ = video_config.max_frame_rate;
 
     // Asynchronous initialization call; NotifyInitializeDone or NotifyError
     // will be called once the HW is initialized.
     video_encode_accelerator_->Initialize(
         media::VideoFrame::I420,
@@ skipping 161 matching lines @@
       VLOG(1) << "BitstreamBufferReady(): invalid payload_size = "
               << payload_size;
       NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
       return;
     }
     if (encoded_frame_data_storage_.empty()) {
       NOTREACHED();
       NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
       return;
     }
-    scoped_ptr<transport::EncodedVideoFrame>
-        encoded_frame(new transport::EncodedVideoFrame());
+    scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
 
     encoded_frame->codec = codec_;
     encoded_frame->key_frame = key_frame;
     encoded_frame->last_referenced_frame_id = last_encoded_frame_id_;
     last_encoded_frame_id_++;
     encoded_frame->frame_id = last_encoded_frame_id_;
     if (key_frame) {
       // Self referenced.
       encoded_frame->last_referenced_frame_id = encoded_frame->frame_id;
     }
@@ skipping 36 matching lines @@
 
   virtual ~LocalVideoEncodeAcceleratorClient() {}
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories_;
   scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner_;
   const base::WeakPtr<ExternalVideoEncoder> weak_owner_;
 
   scoped_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
   int max_frame_rate_;
-  transport::VideoCodec codec_;
+  VideoCodec codec_;
   uint32 last_encoded_frame_id_;
 
   // Shared memory buffers for input/output with the VideoAccelerator.
   ScopedVector<base::SharedMemory> input_buffers_;
   ScopedVector<base::SharedMemory> output_buffers_;
 
   // Input buffers ready to be filled with input from Encode(). As a LIFO since
   // we don't care about ordering.
   std::vector<int> input_buffers_free_;
 
@@ skipping 96 matching lines @@
   // Do nothing not supported.
 }
 
 int ExternalVideoEncoder::NumberOfSkippedFrames() const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   return skip_count_;
 }
 
 }  //  namespace cast
 }  //  namespace media