Move WebMediaPlayerImpl and its dependencies to media/blink.

media/blink/buffered_resource_loader.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_resource_loader.h"
+#include "media/blink/buffered_resource_loader.h"
 
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "content/public/common/url_constants.h"
-#include "content/renderer/media/cache_util.h"
 #include "media/base/media_log.h"
+#include "media/blink/cache_util.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebURLLoaderOptions.h"
 
 using blink::WebFrame;
 using blink::WebString;
 using blink::WebURLError;
 using blink::WebURLLoader;
 using blink::WebURLLoaderOptions;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
-namespace content {
+namespace media {
 
 static const int kHttpOK = 200;
 static const int kHttpPartialContent = 206;
 
 // Define the number of bytes in a megabyte.
 static const int kMegabyte = 1024 * 1024;
 
 // Minimum capacity of the buffer in forward or backward direction.
 //
 // 2MB is an arbitrary limit; it just seems to be "good enough" in practice.
@@ skipping 54 matching lines @@
 }
 
 BufferedResourceLoader::BufferedResourceLoader(
     const GURL& url,
     CORSMode cors_mode,
     int64 first_byte_position,
     int64 last_byte_position,
     DeferStrategy strategy,
     int bitrate,
     float playback_rate,
-    media::MediaLog* media_log)
+    MediaLog* media_log)
     : buffer_(kMinBufferCapacity, kMinBufferCapacity),
       loader_failed_(false),
       defer_strategy_(strategy),
       might_be_reused_from_cache_in_future_(true),
       range_supported_(false),
       saved_forward_capacity_(0),
       url_(url),
       cors_mode_(cors_mode),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
@@ skipping 252 matching lines @@
   if (start_cb_.is_null())
     return;
 
   uint32 reasons = GetReasonsForUncacheability(response);
   might_be_reused_from_cache_in_future_ = reasons == 0;
   UMA_HISTOGRAM_BOOLEAN("Media.CacheUseful", reasons == 0);
   int shift = 0;
   int max_enum = base::bits::Log2Ceiling(kMaxReason);
   while (reasons) {
     DCHECK_LT(shift, max_enum);  // Sanity check.
-    if (reasons & 0x1)
-      UMA_HISTOGRAM_ENUMERATION("Media.UncacheableReason", shift, max_enum);
+    if (reasons & 0x1) {
+      UMA_HISTOGRAM_ENUMERATION("Media.UncacheableReason",
+                                shift,
+                                max_enum); // PRESUBMIT_IGNORE_UMA_MAX
+    }
+
     reasons >>= 1;
     ++shift;
   }
 
   // Expected content length can be |kPositionNotSpecified|, in that case
   // |content_length_| is not specified and this is a streaming response.
   content_length_ = response.expectedContentLength();
 
   // We make a strong assumption that when we reach here we have either
   // received a response from HTTP/HTTPS protocol or the request was
@@ skipping 386 matching lines @@
 }
 
 void BufferedResourceLoader::Log() {
   media_log_->AddEvent(
       media_log_->CreateBufferedExtentsChangedEvent(
           offset_ - buffer_.backward_bytes(),
           offset_,
           offset_ + buffer_.forward_bytes()));
 }
 
-}  // namespace content
+}  // namespace media