Media Controls: Fix seek to end when max attr is rounded up

third_party/WebKit/Source/core/html/shadow/MediaControlsTest.cpp

 // Copyright 2015 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 "core/html/shadow/MediaControls.h"
 
 #include <limits>
 #include <memory>
 #include "core/HTMLNames.h"
 #include "core/css/StylePropertySet.h"
 #include "core/dom/Document.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/StyleEngine.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLVideoElement.h"
+#include "core/html/shadow/MediaControlElementTypes.h"
 #include "core/loader/EmptyClients.h"
 #include "core/testing/DummyPageHolder.h"
 #include "platform/heap/Handle.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/WebMediaPlayer.h"
 #include "public/platform/WebSize.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackAvailability.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackClient.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 namespace {
 
 class MockVideoWebMediaPlayer : public WebMediaPlayer {
  public:
   // WebMediaPlayer overrides:
   void load(LoadType, const WebMediaPlayerSource&, CORSMode) override{};
   void play() override{};
   void pause() override{};
   bool supportsSave() const override { return false; };
   void seek(double seconds) override{};
   void setRate(double) override{};
   void setVolume(double) override{};
   WebTimeRanges buffered() const override { return WebTimeRanges(); };
-  WebTimeRanges seekable() const override { return WebTimeRanges(); };
+  WebTimeRanges seekable() const override { return m_seekable; };
   void setSinkId(const WebString& sinkId,
                  const WebSecurityOrigin&,
                  WebSetSinkIdCallbacks*) override{};
   bool hasVideo() const override { return true; };
   bool hasAudio() const override { return false; };
   WebSize naturalSize() const override { return WebSize(0, 0); };
   bool paused() const override { return false; };
   bool seeking() const override { return false; };
   double duration() const override { return 0.0; };
   double currentTime() const override { return 0.0; };
   NetworkState getNetworkState() const override { return NetworkStateEmpty; };
   ReadyState getReadyState() const override { return ReadyStateHaveNothing; };
   WebString getErrorMessage() override { return WebString(); };
   bool didLoadingProgress() override { return false; };
   bool hasSingleSecurityOrigin() const override { return true; };
   bool didPassCORSAccessCheck() const override { return true; };
   double mediaTimeForTimeValue(double timeValue) const override {
     return timeValue;
   };
   unsigned decodedFrameCount() const override { return 0; };
   unsigned droppedFrameCount() const override { return 0; };
   size_t audioDecodedByteCount() const override { return 0; };
   size_t videoDecodedByteCount() const override { return 0; };
   void paint(WebCanvas*, const WebRect&, PaintFlags&) override{};
+
+  WebTimeRanges m_seekable;
 };
 
 class MockWebRemotePlaybackClient : public WebRemotePlaybackClient {
  public:
   void stateChanged(WebRemotePlaybackState) override {}
   void availabilityChanged(
       WebRemotePlaybackAvailability availability) override {
     m_availability = availability;
   }
   void promptCancelled() override {}
@@ skipping 90 matching lines @@
     m_mediaControls->mediaElement().clientWidth();
   }
 
   void simulateHideMediaControlsTimerFired() {
     m_mediaControls->hideMediaControlsTimerFired(nullptr);
   }
 
   void simulateLoadedMetadata() { m_mediaControls->onLoadedMetadata(); }
 
   MediaControls& mediaControls() { return *m_mediaControls; }
+  MockVideoWebMediaPlayer* webMediaPlayer() {
+    return static_cast<MockVideoWebMediaPlayer*>(
+        mediaControls().mediaElement().webMediaPlayer());
+  }
   Document& document() { return m_pageHolder->document(); }
 
  private:
   std::unique_ptr<DummyPageHolder> m_pageHolder;
   Persistent<MediaControls> m_mediaControls;
 };
 
 TEST_F(MediaControlsTest, HideAndShow) {
   mediaControls().mediaElement().setBooleanAttribute(HTMLNames::controlsAttr,
                                                      true);
@@ skipping 202 matching lines @@
       mediaControls(), "-internal-media-controls-download-button");
   ASSERT_NE(nullptr, downloadButton);
 
   // Download button should not be displayed for HLS streams.
   mediaControls().mediaElement().setSrc("https://example.com/foo.m3u8");
   testing::runPendingTasks();
   simulateLoadedMetadata();
   EXPECT_FALSE(isElementVisible(*downloadButton));
 }
 
+TEST_F(MediaControlsTest, TimelineSeekToRoundedEnd) {
+  ensureLayout();
+
+  MediaControlTimelineElement* timeline =
+      static_cast<MediaControlTimelineElement*>(getElementByShadowPseudoId(
+          mediaControls(), "-webkit-media-controls-timeline"));
+  ASSERT_NE(nullptr, timeline);
+
+  mediaControls().mediaElement().setSrc("https://example.com/foo.mp4");
+  testing::runPendingTasks();
+
+  // Tests the case where the real length of the video, |exactDuration|, gets
+  // rounded up slightly to |roundedUpDuration| when setting the timeline's
+  // |max| attribute (crbug.com/695065).
+  double exactDuration = 596.586667;
+  double roundedUpDuration = 596.587;
+
+  WebTimeRange timeRange(0.0, exactDuration);
+  webMediaPlayer()->m_seekable.assign(&timeRange, 1);
+  mediaControls().mediaElement().durationChanged(exactDuration,
+                                                 false /* requestSeek */);
+  simulateLoadedMetadata();
+
+  // Simulate a click slightly past the end of the track of the timeline's
+  // underlying <input type="range">. This would set the |value| to the |max|
+  // attribute, which can be slightly rounded relative to the duration.
+  timeline->setValueAsNumber(roundedUpDuration, ASSERT_NO_EXCEPTION);
+  ASSERT_EQ(roundedUpDuration, timeline->valueAsNumber());
+  EXPECT_EQ(0.0, mediaControls().mediaElement().currentTime());
+  timeline->dispatchInputEvent();
+  EXPECT_EQ(exactDuration, mediaControls().mediaElement().currentTime());
+}
+
 }  // namespace blink