Rename WebKit namespace to blink (part 3)

content/renderer/media/android/webmediaplayer_android.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/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 29 matching lines @@
 #include "ui/gfx/image/image.h"
 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
 
 #if defined(GOOGLE_TV)
 #include "content/renderer/media/media_stream_audio_renderer.h"
 #include "content/renderer/media/media_stream_client.h"
 #endif
 
 static const uint32 kGLTextureExternalOES = 0x8D65;
 
-using WebKit::WebMediaPlayer;
-using WebKit::WebSize;
-using WebKit::WebString;
-using WebKit::WebTimeRanges;
-using WebKit::WebURL;
+using blink::WebMediaPlayer;
+using blink::WebSize;
+using blink::WebString;
+using blink::WebTimeRanges;
+using blink::WebURL;
 using media::MediaPlayerAndroid;
 using media::VideoFrame;
 
 namespace {
 // Prefix for histograms related to Encrypted Media Extensions.
 const char* kMediaEme = "Media.EME.";
 }  // namespace
 
 namespace content {
 
 // static
 void WebMediaPlayerAndroid::OnReleaseRemotePlaybackTexture(
     const scoped_refptr<base::MessageLoopProxy>& main_loop,
     const base::WeakPtr<WebMediaPlayerAndroid>& player,
     uint32 sync_point) {
   main_loop->PostTask(
       FROM_HERE,
       base::Bind(&WebMediaPlayerAndroid::DoReleaseRemotePlaybackTexture,
                  player,
                  sync_point));
 }
 
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
-    WebKit::WebFrame* frame,
-    WebKit::WebMediaPlayerClient* client,
+    blink::WebFrame* frame,
+    blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     RendererMediaPlayerManager* manager,
     StreamTextureFactory* factory,
     const scoped_refptr<base::MessageLoopProxy>& media_loop,
     media::MediaLog* media_log)
     : frame_(frame),
       client_(client),
       delegate_(delegate),
       buffered_(1u),
       main_loop_(base::MessageLoopProxy::current()),
@@ skipping 50 matching lines @@
     }
   }
 
   // Defer stream texture creation until we are sure it's necessary.
   stream_id_ = 0;
   needs_establish_peer_ = false;
   current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
 #endif
   TryCreateStreamTextureProxyIfNeeded();
 
-  if (WebKit::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled()) {
+  if (blink::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled()) {
     // TODO(xhwang): Report an error when there is encrypted stream but EME is
     // not enabled. Currently the player just doesn't start and waits for ever.
     decryptor_.reset(new ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
         client,
         frame,
 #else
         manager_,
         player_id_,  // TODO(xhwang): Use media_keys_id when MediaKeys are
                      // separated from WebMediaPlayer.
@@ skipping 12 matching lines @@
 
   if (manager_) {
     manager_->DestroyPlayer(player_id_);
     manager_->UnregisterMediaPlayer(player_id_);
   }
 
   if (stream_id_)
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
 
   if (remote_playback_texture_id_) {
-    WebKit::WebGraphicsContext3D* context =
+    blink::WebGraphicsContext3D* context =
         stream_texture_factory_->Context3d();
     if (context->makeContextCurrent())
       context->deleteTexture(remote_playback_texture_id_);
   }
 
   if (base::MessageLoop::current())
     base::MessageLoop::current()->RemoveDestructionObserver(this);
 
   if (player_type_ == MEDIA_PLAYER_TYPE_MEDIA_SOURCE && delegate_)
     delegate_->PlayerGone(this);
@@ skipping 11 matching lines @@
     }
   }
   if (demuxer_ && !destroy_demuxer_cb_.is_null()) {
     media_source_delegate_.reset();
     destroy_demuxer_cb_.Run();
   }
 #endif
 }
 
 void WebMediaPlayerAndroid::load(LoadType load_type,
-                                 const WebKit::WebURL& url,
+                                 const blink::WebURL& url,
                                  CORSMode cors_mode) {
   switch (load_type) {
     case LoadTypeURL:
       player_type_ = MEDIA_PLAYER_TYPE_URL;
       break;
 
     case LoadTypeMediaSource:
       player_type_ = MEDIA_PLAYER_TYPE_MEDIA_SOURCE;
       break;
 
@@ skipping 275 matching lines @@
   // TODO(hclam): If this stream is not seekable this should return 0.
   return duration();
 }
 
 bool WebMediaPlayerAndroid::didLoadingProgress() const {
   bool ret = did_loading_progress_;
   did_loading_progress_ = false;
   return ret;
 }
 
-void WebMediaPlayerAndroid::paint(WebKit::WebCanvas* canvas,
-                                  const WebKit::WebRect& rect,
+void WebMediaPlayerAndroid::paint(blink::WebCanvas* canvas,
+                                  const blink::WebRect& rect,
                                   unsigned char alpha) {
   NOTIMPLEMENTED();
 }
 
 bool WebMediaPlayerAndroid::copyVideoTextureToPlatformTexture(
-    WebKit::WebGraphicsContext3D* web_graphics_context,
+    blink::WebGraphicsContext3D* web_graphics_context,
     unsigned int texture,
     unsigned int level,
     unsigned int internal_format,
     unsigned int type,
     bool premultiply_alpha,
     bool flip_y) {
   if (is_remote_ || !texture_id_)
     return false;
 
   // For hidden video element (with style "display:none"), ensure the texture
@@ skipping 372 matching lines @@
     current_frame_ = NULL;
   }
   is_remote_ = false;
   manager_ = NULL;
 }
 
 void WebMediaPlayerAndroid::DrawRemotePlaybackIcon() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!video_weblayer_)
     return;
-  WebKit::WebGraphicsContext3D* context = stream_texture_factory_->Context3d();
+  blink::WebGraphicsContext3D* context = stream_texture_factory_->Context3d();
   if (!context->makeContextCurrent())
     return;
 
   // TODO(johnme): Should redraw this frame if the layer bounds change; but
   // there seems no easy way to listen for the layer resizing (as opposed to
   // OnVideoSizeChanged, which is when the frame sizes of the video file
   // change). Perhaps have to poll (on main thread of course)?
   gfx::Size video_size_css_px = video_weblayer_->bounds();
   float device_scale_factor = frame_->view()->deviceScaleFactor();
   // canvas_size will be the size in device pixels when pageScaleFactor == 1
@@ skipping 242 matching lines @@
 // The following EME related code is copied from WebMediaPlayerImpl.
 // TODO(xhwang): Remove duplicate code between WebMediaPlayerAndroid and
 // WebMediaPlayerImpl.
 // TODO(kjyoun): Update Google TV EME implementation to use IPC.
 
 // Helper functions to report media EME related stats to UMA. They follow the
 // convention of more commonly used macros UMA_HISTOGRAM_ENUMERATION and
 // UMA_HISTOGRAM_COUNTS. The reason that we cannot use those macros directly is
 // that UMA_* macros require the names to be constant throughout the process'
 // lifetime.
-static void EmeUMAHistogramEnumeration(const WebKit::WebString& key_system,
+static void EmeUMAHistogramEnumeration(const blink::WebString& key_system,
                                        const std::string& method,
                                        int sample,
                                        int boundary_value) {
   base::LinearHistogram::FactoryGet(
       kMediaEme + KeySystemNameForUMA(key_system) + "." + method,
       1, boundary_value, boundary_value + 1,
       base::Histogram::kUmaTargetedHistogramFlag)->Add(sample);
 }
 
-static void EmeUMAHistogramCounts(const WebKit::WebString& key_system,
+static void EmeUMAHistogramCounts(const blink::WebString& key_system,
                                   const std::string& method,
                                   int sample) {
   // Use the same parameters as UMA_HISTOGRAM_COUNTS.
   base::Histogram::FactoryGet(
       kMediaEme + KeySystemNameForUMA(key_system) + "." + method,
       1, 1000000, 50, base::Histogram::kUmaTargetedHistogramFlag)->Add(sample);
 }
 
 // Helper enum for reporting generateKeyRequest/addKey histograms.
 enum MediaKeyException {
@@ skipping 149 matching lines @@
 
 void WebMediaPlayerAndroid::OnKeyError(const std::string& session_id,
                                        media::MediaKeys::KeyError error_code,
                                        int system_code) {
   EmeUMAHistogramEnumeration(current_key_system_, "KeyError",
                              error_code, media::MediaKeys::kMaxKeyError);
 
   client_->keyError(
       current_key_system_,
       WebString::fromUTF8(session_id),
-      static_cast<WebKit::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
+      static_cast<blink::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
       system_code);
 }
 
 void WebMediaPlayerAndroid::OnKeyMessage(const std::string& session_id,
                                          const std::vector<uint8>& message,
                                          const std::string& destination_url) {
   const GURL destination_url_gurl(destination_url);
   DLOG_IF(WARNING, !destination_url.empty() && !destination_url_gurl.is_valid())
       << "Invalid URL in destination_url: " << destination_url;
 
   client_->keyMessage(current_key_system_,
                       WebString::fromUTF8(session_id),
                       message.empty() ? NULL : &message[0],
                       message.size(),
                       destination_url_gurl);
 }
 
 void WebMediaPlayerAndroid::OnMediaSourceOpened(
-    WebKit::WebMediaSource* web_media_source) {
+    blink::WebMediaSource* web_media_source) {
   client_->mediaSourceOpened(web_media_source);
 }
 
 void WebMediaPlayerAndroid::OnNeedKey(const std::string& type,
                                       const std::vector<uint8>& init_data) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   // Do not fire NeedKey event if encrypted media is not enabled.
-  if (!WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled() &&
-      !WebKit::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled()) {
+  if (!blink::WebRuntimeFeatures::isEncryptedMediaEnabled() &&
+      !blink::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled()) {
     return;
   }
 
   UMA_HISTOGRAM_COUNTS(kMediaEme + std::string("NeedKey"), 1);
 
   DCHECK(init_data_type_.empty() || type.empty() || type == init_data_type_);
   if (init_data_type_.empty())
     init_data_type_ = type;
 
   const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
@@ skipping 14 matching lines @@
   demuxer_ = demuxer;
   destroy_demuxer_cb_ = destroy_demuxer_cb;
   return true;
 }
 #endif
 
 void WebMediaPlayerAndroid::DoReleaseRemotePlaybackTexture(uint32 sync_point) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(remote_playback_texture_id_);
 
-  WebKit::WebGraphicsContext3D* context =
+  blink::WebGraphicsContext3D* context =
       stream_texture_factory_->Context3d();
 
   if (sync_point)
     context->waitSyncPoint(sync_point);
   context->deleteTexture(remote_playback_texture_id_);
   remote_playback_texture_id_ = 0;
 }
 
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (manager_->CanEnterFullscreen(frame_)) {
     manager_->EnterFullscreen(player_id_);
     SetNeedsEstablishPeer(false);
   }
 }
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   manager_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace content