Rename WebKit namespace to blink (part 3)

content/renderer/media/webmediaplayer_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 42 matching lines @@
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "v8/include/v8.h"
 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
 
-using WebKit::WebCanvas;
-using WebKit::WebMediaPlayer;
-using WebKit::WebRect;
-using WebKit::WebSize;
-using WebKit::WebString;
+using blink::WebCanvas;
+using blink::WebMediaPlayer;
+using blink::WebRect;
+using blink::WebSize;
+using blink::WebString;
 using media::PipelineStatus;
 
 namespace {
 
 // Amount of extra memory used by each player instance reported to V8.
 // It is not exact number -- first, it differs on different platforms,
 // and second, it is very hard to calculate. Instead, use some arbitrary
 // value that will cause garbage collection from time to time. We don't want
 // it to happen on every allocation, but don't want 5k players to sit in memory
 // either. Looks that chosen constant achieves both goals, at least for audio
@@ skipping 44 matching lines @@
 
 #define BIND_TO_RENDER_LOOP_2(function, arg1, arg2) \
   media::BindToLoop(main_loop_, base::Bind(function, AsWeakPtr(), arg1, arg2))
 
 static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
                                 const std::string& error) {
   media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
 }
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
-    WebKit::WebFrame* frame,
-    WebKit::WebMediaPlayerClient* client,
+    blink::WebFrame* frame,
+    blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     const WebMediaPlayerParams& params)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       main_loop_(base::MessageLoopProxy::current()),
       media_loop_(params.message_loop_proxy()),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
@@ skipping 33 matching lines @@
   //
   // TODO(enal): remove when we get rid of per-audio-stream thread.
   main_loop_->PostTask(
       FROM_HERE,
       base::Bind(&WebMediaPlayerImpl::IncrementExternallyAllocatedMemory,
                  AsWeakPtr()));
 
   // Also we want to be notified of |main_loop_| destruction.
   base::MessageLoop::current()->AddDestructionObserver(this);
 
-  if (WebKit::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled()) {
+  if (blink::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled()) {
     decryptor_.reset(new ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
         client,
         frame,
 #endif
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyAdded),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyError),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyMessage)));
   }
 
@@ skipping 50 matching lines @@
   if (url.SchemeIs("javascript")) return kJavascriptURLScheme;
   if (url.SchemeIs("file")) return kFileURLScheme;
   if (url.SchemeIs("blob")) return kBlobURLScheme;
   if (url.SchemeIs("data")) return kDataURLScheme;
   if (url.SchemeIs("filesystem")) return kFileSystemScheme;
   return kUnknownURLScheme;
 }
 
 }  // anonymous namespace
 
-void WebMediaPlayerImpl::load(LoadType load_type, const WebKit::WebURL& url,
+void WebMediaPlayerImpl::load(LoadType load_type, const blink::WebURL& url,
                               CORSMode cors_mode) {
   if (!defer_load_cb_.is_null()) {
     defer_load_cb_.Run(base::Bind(
         &WebMediaPlayerImpl::DoLoad, AsWeakPtr(), load_type, url, cors_mode));
     return;
   }
   DoLoad(load_type, url, cors_mode);
 }
 
 void WebMediaPlayerImpl::DoLoad(LoadType load_type,
-                                const WebKit::WebURL& url,
+                                const blink::WebURL& url,
                                 CORSMode cors_mode) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   GURL gurl(url);
   UMA_HISTOGRAM_ENUMERATION("Media.URLScheme", URLScheme(gurl), kMaxURLScheme);
 
   // Set subresource URL for crash reporting.
   base::debug::SetCrashKeyValue("subresource_url", gurl.spec());
 
   load_type_ = load_type;
@@ skipping 148 matching lines @@
 
   return pipeline_->HasVideo();
 }
 
 bool WebMediaPlayerImpl::hasAudio() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   return pipeline_->HasAudio();
 }
 
-WebKit::WebSize WebMediaPlayerImpl::naturalSize() const {
+blink::WebSize WebMediaPlayerImpl::naturalSize() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   gfx::Size size;
   pipeline_->GetNaturalVideoSize(&size);
-  return WebKit::WebSize(size);
+  return blink::WebSize(size);
 }
 
 bool WebMediaPlayerImpl::paused() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   return pipeline_->GetPlaybackRate() == 0.0f;
 }
 
 bool WebMediaPlayerImpl::seeking() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
@@ skipping 21 matching lines @@
 WebMediaPlayer::NetworkState WebMediaPlayerImpl::networkState() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerImpl::readyState() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return ready_state_;
 }
 
-const WebKit::WebTimeRanges& WebMediaPlayerImpl::buffered() {
+const blink::WebTimeRanges& WebMediaPlayerImpl::buffered() {
   DCHECK(main_loop_->BelongsToCurrentThread());
-  WebKit::WebTimeRanges web_ranges(
+  blink::WebTimeRanges web_ranges(
       ConvertToWebTimeRanges(pipeline_->GetBufferedTimeRanges()));
   buffered_.swap(web_ranges);
   return buffered_;
 }
 
 double WebMediaPlayerImpl::maxTimeSeekable() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // If we haven't even gotten to ReadyStateHaveMetadata yet then just
   // return 0 so that the seekable range is empty.
@@ skipping 109 matching lines @@
     const scoped_refptr<media::VideoFrame>& frame) {
   if (!accelerated_compositing_reported_) {
     accelerated_compositing_reported_ = true;
     DCHECK(frame_->view()->isAcceleratedCompositingActive());
     UMA_HISTOGRAM_BOOLEAN("Media.AcceleratedCompositingActive", true);
   }
   TRACE_EVENT_ASYNC_END0("media", "WebMediaPlayerImpl:compositing", this);
 }
 
 bool WebMediaPlayerImpl::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) {
   scoped_refptr<media::VideoFrame> video_frame;
   {
     base::AutoLock auto_lock(lock_);
     video_frame = current_frame_;
@@ skipping 58 matching lines @@
   // performance will be better when it is added than not.
   web_graphics_context->flush();
   return true;
 }
 
 // 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 275 matching lines @@
                          init_data_ptr,
                          init_data.size());
 }
 
 scoped_ptr<media::TextTrack>
 WebMediaPlayerImpl::OnTextTrack(media::TextKind kind,
                                 const std::string& label,
                                 const std::string& language) {
   typedef WebInbandTextTrackImpl::Kind webkind_t;
   const webkind_t webkind = static_cast<webkind_t>(kind);
-  const WebKit::WebString weblabel = WebKit::WebString::fromUTF8(label);
-  const WebKit::WebString weblanguage = WebKit::WebString::fromUTF8(language);
+  const blink::WebString weblabel = blink::WebString::fromUTF8(label);
+  const blink::WebString weblanguage = blink::WebString::fromUTF8(language);
 
   WebInbandTextTrackImpl* const text_track =
     new WebInbandTextTrackImpl(webkind, weblabel, weblanguage,
                                text_track_index_++);
 
   return scoped_ptr<media::TextTrack>(new TextTrackImpl(GetClient(),
                                                         text_track));
 }
 
 void WebMediaPlayerImpl::OnKeyError(const std::string& session_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   EmeUMAHistogramEnumeration(current_key_system_, "KeyError",
                              error_code, media::MediaKeys::kMaxKeyError);
 
   GetClient()->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 WebMediaPlayerImpl::OnKeyMessage(const std::string& session_id,
                                       const std::vector<uint8>& message,
                                       const std::string& default_url) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   const GURL default_url_gurl(default_url);
   DLOG_IF(WARNING, !default_url.empty() && !default_url_gurl.is_valid())
@@ skipping 197 matching lines @@
     v8::V8::AdjustAmountOfExternalAllocatedMemory(-kPlayerExtraMemory);
     incremented_externally_allocated_memory_ = false;
   }
 
   // Release any final references now that everything has stopped.
   pipeline_.reset();
   demuxer_.reset();
   data_source_.reset();
 }
 
-WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
+blink::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK(client_);
   return client_;
 }
 
-WebKit::WebAudioSourceProvider* WebMediaPlayerImpl::audioSourceProvider() {
+blink::WebAudioSourceProvider* WebMediaPlayerImpl::audioSourceProvider() {
   return audio_source_provider_.get();
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 double WebMediaPlayerImpl::GetPipelineDuration() const {
@@ skipping 59 matching lines @@
   // The |current_frame_| wasn't painted, it is being replaced, and we haven't
   // even gotten the chance to request a repaint for it yet. Mark it as dropped.
   TRACE_EVENT0("media", "WebMediaPlayerImpl:frameDropped");
   DVLOG(1) << "Frame dropped before being painted: "
            << current_frame_->GetTimestamp().InSecondsF();
   if (frames_dropped_before_paint_ < kuint32max)
     frames_dropped_before_paint_++;
 }
 
 }  // namespace content