Move WebMediaPlayerImpl and its dependencies to media/blink.

media/blink/buffered_data_source.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 "content/renderer/media/buffered_data_source.h"
+#include "media/blink/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
-#include "content/public/common/url_constants.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
 
 using blink::WebFrame;
 
 namespace {
 
 // BufferedDataSource has an intermediate buffer, this value governs the initial
 // size of that buffer. It is set to 32KB because this is a typical read size
 // of FFmpeg.
 const int kInitialReadBufferSize = 32768;
 
 // Number of cache misses we allow for a single Read() before signaling an
 // error.
 const int kNumCacheMissRetries = 3;
 
 }  // namespace
 
-namespace content {
+namespace media {
 
 class BufferedDataSource::ReadOperation {
  public:
   ReadOperation(int64 position, int size, uint8* data,
-                const media::DataSource::ReadCB& callback);
+                const DataSource::ReadCB& callback);
   ~ReadOperation();
 
   // Runs |callback_| with the given |result|, deleting the operation
   // afterwards.
   static void Run(scoped_ptr<ReadOperation> read_op, int result);
 
   // State for the number of times this read operation has been retried.
   int retries() { return retries_; }
   void IncrementRetries() { ++retries_; }
 
   int64 position() { return position_; }
   int size() { return size_; }
   uint8* data() { return data_; }
 
  private:
   int retries_;
 
   const int64 position_;
   const int size_;
   uint8* data_;
-  media::DataSource::ReadCB callback_;
+  DataSource::ReadCB callback_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ReadOperation);
 };
 
 BufferedDataSource::ReadOperation::ReadOperation(
     int64 position, int size, uint8* data,
-    const media::DataSource::ReadCB& callback)
+    const DataSource::ReadCB& callback)
     : retries_(0),
       position_(position),
       size_(size),
       data_(data),
       callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
 BufferedDataSource::ReadOperation::~ReadOperation() {
   DCHECK(callback_.is_null());
 }
 
 // static
 void BufferedDataSource::ReadOperation::Run(
     scoped_ptr<ReadOperation> read_op, int result) {
   base::ResetAndReturn(&read_op->callback_).Run(result);
 }
 
 BufferedDataSource::BufferedDataSource(
     const GURL& url,
     BufferedResourceLoader::CORSMode cors_mode,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     WebFrame* frame,
-    media::MediaLog* media_log,
+    MediaLog* media_log,
     BufferedDataSourceHost* host,
     const DownloadingCB& downloading_cb)
     : url_(url),
       cors_mode_(cors_mode),
       total_bytes_(kPositionNotSpecified),
       streaming_(false),
       frame_(frame),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_task_runner_(task_runner),
@@ skipping 102 matching lines @@
   media_has_played_ = true;
   UpdateDeferStrategy(false);
 }
 
 void BufferedDataSource::MediaIsPaused() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   UpdateDeferStrategy(true);
 }
 
 /////////////////////////////////////////////////////////////////////////////
-// media::DataSource implementation.
+// DataSource implementation.
 void BufferedDataSource::Stop() {
   {
     base::AutoLock auto_lock(lock_);
     StopInternal_Locked();
   }
 
   render_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BufferedDataSource::StopLoader, weak_factory_.GetWeakPtr()));
 }
 
 void BufferedDataSource::SetBitrate(int bitrate) {
   render_task_runner_->PostTask(FROM_HERE,
                          base::Bind(&BufferedDataSource::SetBitrateTask,
                                     weak_factory_.GetWeakPtr(),
                                     bitrate));
 }
 
 void BufferedDataSource::Read(
     int64 position, int size, uint8* data,
-    const media::DataSource::ReadCB& read_cb) {
+    const DataSource::ReadCB& read_cb) {
   DVLOG(1) << "Read: " << position << " offset, " << size << " bytes";
   DCHECK(!read_cb.is_null());
 
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(!read_op_);
 
     if (stop_signal_received_) {
       read_cb.Run(kReadError);
       return;
@@ skipping 285 matching lines @@
     return;
   }
 
   // If media is currently playing or the page indicated preload=auto or the
   // the server does not support the byte range request or we do not want to go
   // too far ahead of the read head, use threshold strategy to enable/disable
   // deferring when the buffer is full/depleted.
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 }
 
-}  // namespace content
+}  // namespace media