Move WebMediaPlayerImpl and its dependencies to media/blink.

content/renderer/media/android/media_source_delegate.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/android/media_source_delegate.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/renderer/media/android/renderer_demuxer_android.h"
-#include "content/renderer/media/webmediaplayer_util.h"
-#include "content/renderer/media/webmediasource_impl.h"
 #include "media/base/android/demuxer_stream_player_params.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
+#include "media/blink/webmediaplayer_util.h"
+#include "media/blink/webmediasource_impl.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 
 using media::DemuxerStream;
 using media::DemuxerConfigs;
 using media::DemuxerData;
 using blink::WebMediaPlayer;
 using blink::WebString;
@@ skipping 152 matching lines @@
 void MediaSourceDelegate::InitializeDemuxer() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   demuxer_client_->AddDelegate(demuxer_client_id_, this);
   chunk_demuxer_->Initialize(this,
                              base::Bind(&MediaSourceDelegate::OnDemuxerInitDone,
                                         media_weak_factory_.GetWeakPtr()),
                              false);
 }
 
 blink::WebTimeRanges MediaSourceDelegate::Buffered() const {
-  return ConvertToWebTimeRanges(buffered_time_ranges_);
+  return media::ConvertToWebTimeRanges(buffered_time_ranges_);
 }
 
 size_t MediaSourceDelegate::DecodedFrameCount() const {
   return statistics_.video_frames_decoded;
 }
 
 size_t MediaSourceDelegate::DroppedFrameCount() const {
   return statistics_.video_frames_dropped;
 }
 
@@ skipping 452 matching lines @@
 
 base::TimeDelta MediaSourceDelegate::GetDuration() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   if (!chunk_demuxer_)
     return media::kNoTimestamp();
 
   double duration = chunk_demuxer_->GetDuration();
   if (duration == std::numeric_limits<double>::infinity())
     return media::kInfiniteDuration();
 
-  return ConvertSecondsToTimestamp(duration);
+  return media::ConvertSecondsToTimestamp(duration);
 }
 
 void MediaSourceDelegate::OnDemuxerOpened() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (media_source_opened_cb_.is_null())
     return;
 
-  media_source_opened_cb_.Run(new WebMediaSourceImpl(
+  media_source_opened_cb_.Run(new media::WebMediaSourceImpl(
       chunk_demuxer_.get(), base::Bind(&LogMediaSourceError, media_log_)));
 }
 
 void MediaSourceDelegate::OnNeedKey(const std::string& type,
                                     const std::vector<uint8>& init_data) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (need_key_cb_.is_null())
     return;
 
   need_key_cb_.Run(type, init_data);
@@ skipping 67 matching lines @@
     configs->video_size = config.natural_size();
     configs->is_video_encrypted = config.is_encrypted();
     configs->video_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
     return true;
   }
   return false;
 }
 
 }  // namespace content