Rename WebKit namespace to blink (part 3)

content/renderer/media/webmediaplayer_ms.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/webmediaplayer_ms.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "cc/layers/video_layer.h"
 #include "content/renderer/media/media_stream_audio_renderer.h"
 #include "content/renderer/media/media_stream_client.h"
 #include "content/renderer/media/video_frame_provider.h"
 #include "content/renderer/media/webmediaplayer_delegate.h"
 #include "content/renderer/media/webmediaplayer_util.h"
 #include "media/base/media_log.h"
 #include "media/base/video_frame.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
 
-using WebKit::WebCanvas;
-using WebKit::WebMediaPlayer;
-using WebKit::WebRect;
-using WebKit::WebSize;
+using blink::WebCanvas;
+using blink::WebMediaPlayer;
+using blink::WebRect;
+using blink::WebSize;
 
 namespace content {
 
 WebMediaPlayerMS::WebMediaPlayerMS(
-    WebKit::WebFrame* frame,
-    WebKit::WebMediaPlayerClient* client,
+    blink::WebFrame* frame,
+    blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     MediaStreamClient* media_stream_client,
     media::MediaLog* media_log)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       buffered_(static_cast<size_t>(1)),
       client_(client),
       delegate_(delegate),
       media_stream_client_(media_stream_client),
@@ skipping 26 matching lines @@
     audio_renderer_->Stop();
 
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_.get())
     delegate_->PlayerGone(this);
 }
 
 void WebMediaPlayerMS::load(LoadType load_type,
-                            const WebKit::WebURL& url,
+                            const blink::WebURL& url,
                             CORSMode cors_mode) {
   DVLOG(1) << "WebMediaPlayerMS::load";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(acolwell): Change this to DCHECK_EQ(load_type,
   // LoadTypeMediaStream) once Blink-side changes land.
   DCHECK_NE(load_type, LoadTypeMediaSource);
 
   GURL gurl(url);
 
@@ skipping 101 matching lines @@
 bool WebMediaPlayerMS::hasVideo() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return (video_frame_provider_.get() != NULL);
 }
 
 bool WebMediaPlayerMS::hasAudio() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return (audio_renderer_.get() != NULL);
 }
 
-WebKit::WebSize WebMediaPlayerMS::naturalSize() const {
+blink::WebSize WebMediaPlayerMS::naturalSize() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   gfx::Size size;
   if (current_frame_.get())
     size = current_frame_->natural_size();
   DVLOG(3) << "WebMediaPlayerMS::naturalSize, " << size.ToString();
-  return WebKit::WebSize(size);
+  return blink::WebSize(size);
 }
 
 bool WebMediaPlayerMS::paused() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return paused_;
 }
 
 bool WebMediaPlayerMS::seeking() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return false;
@@ skipping 19 matching lines @@
   DVLOG(1) << "WebMediaPlayerMS::networkState, state:" << network_state_;
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerMS::readyState() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebMediaPlayerMS::readyState, state:" << ready_state_;
   return ready_state_;
 }
 
-const WebKit::WebTimeRanges& WebMediaPlayerMS::buffered() {
+const blink::WebTimeRanges& WebMediaPlayerMS::buffered() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return buffered_;
 }
 
 double WebMediaPlayerMS::maxTimeSeekable() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return 0.0;
 }
 
 bool WebMediaPlayerMS::didLoadingProgress() const {
@@ skipping 151 matching lines @@
   GetClient()->networkStateChanged();
 }
 
 void WebMediaPlayerMS::SetReadyState(WebMediaPlayer::ReadyState state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ready_state_ = state;
   // Always notify to ensure client has the latest value.
   GetClient()->readyStateChanged();
 }
 
-WebKit::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
+blink::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace content