Replace media::Limits struct with media::limits namespace and update documentation.

webkit/media/webmediaplayer_impl.cc

 // Copyright (c) 2011 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 "webkit/media/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 480 matching lines @@
   if (ready_state_ == WebKit::WebMediaPlayer::HaveNothing)
     return false;
 
   return seeking_;
 }
 
 float WebMediaPlayerImpl::duration() const {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   base::TimeDelta duration = pipeline_->GetMediaDuration();
-  if (duration.InMicroseconds() == media::Limits::kMaxTimeInMicroseconds)
+  if (duration.InMicroseconds() == media::limits::kMaxTimeInMicroseconds)

[Ami GONE FROM CHROMIUM, 2011/12/03 02:11:38]

I *think* this is the only place that cares about \infty and would want to use
the constant I proposed earlier.
But I find myself wondering whether webkit really wants to be getting back
infinity for this float (if it doesn't, then probably the constant and the logic
around it don't need to exist).

[scherkus (not reviewing), 2011/12/06 02:05:57]

we use infinity to represent an unbounded stream/duration unknown stream:
http://www.whatwg.org/specs/web-apps/current-work/multipage/video.html#dom-me...

     return std::numeric_limits<float>::infinity();
   return static_cast<float>(duration.InSecondsF());
 }
 
 float WebMediaPlayerImpl::currentTime() const {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   if (paused_)
     return static_cast<float>(paused_time_.InSecondsF());
   return static_cast<float>(pipeline_->GetCurrentTime().InSecondsF());
 }
@@ skipping 69 matching lines @@
   CGAffineTransform mat = CGContextGetCTM(canvas);
   float scale_x = sqrt(mat.a * mat.a + mat.b * mat.b);
   float scale_y = sqrt(mat.c * mat.c + mat.d * mat.d);
   float inverse_scale_x = SkScalarNearlyZero(scale_x) ? 0.0f : 1.0f / scale_x;
   float inverse_scale_y = SkScalarNearlyZero(scale_y) ? 0.0f : 1.0f / scale_y;
   int scaled_width = static_cast<int>(rect.width * fabs(scale_x));
   int scaled_height = static_cast<int>(rect.height * fabs(scale_y));
 
   // Make sure we don't create a huge canvas.
   // TODO(hclam): Respect the aspect ratio.
-  if (scaled_width > static_cast<int>(media::Limits::kMaxCanvas))
-    scaled_width = media::Limits::kMaxCanvas;
-  if (scaled_height > static_cast<int>(media::Limits::kMaxCanvas))
-    scaled_height = media::Limits::kMaxCanvas;
+  if (scaled_width > static_cast<int>(media::limits::kMaxCanvas))
+    scaled_width = media::limits::kMaxCanvas;
+  if (scaled_height > static_cast<int>(media::limits::kMaxCanvas))
+    scaled_height = media::limits::kMaxCanvas;
 
   // If there is no preexisting platform canvas, or if the size has
   // changed, recreate the canvas.  This is to avoid recreating the bitmap
   // buffer over and over for each frame of video.
   if (!skia_canvas_.get() ||
       skia_canvas_->getDevice()->width() != scaled_width ||
       skia_canvas_->getDevice()->height() != scaled_height) {
     skia_canvas_.reset(
         new skia::PlatformCanvas(scaled_width, scaled_height, true));
   }
@@ skipping 308 matching lines @@
   return client_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_media