Remove the lies WebMediaPlayerImpl is telling V8.

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 47 matching lines @@
 #include "media/filters/video_renderer_impl.h"
 #include "media/filters/vpx_video_decoder.h"
 #include "third_party/WebKit/public/platform/WebMediaSource.h"
 #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/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
-#include "v8/include/v8.h"
 
 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
-// objects. (Do not worry about video objects yet, JS programs do not create
-// thousands of them...)
-const int kPlayerExtraMemory = 1024 * 1024;
-
 // Limits the range of playback rate.
 //
 // TODO(kylep): Revisit these.
 //
 // Vista has substantially lower performance than XP or Windows7.  If you speed
 // up a video too much, it can't keep up, and rendering stops updating except on
 // the time bar. For really high speeds, audio becomes a bottleneck and we just
 // use up the data we have, which may not achieve the speed requested, but will
 // not crash the tab.
 //
@@ skipping 69 matching lines @@
       opaque_(false),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
       pending_seek_(false),
       pending_seek_seconds_(0.0f),
       should_notify_time_changed_(false),
       client_(client),
       delegate_(delegate),
       defer_load_cb_(params.defer_load_cb()),
-      incremented_externally_allocated_memory_(false),
       gpu_factories_(RenderThreadImpl::current()->GetGpuFactories()),
       supports_save_(true),
       chunk_demuxer_(NULL),
       // Threaded compositing isn't enabled universally yet.
       compositor_task_runner_(
           RenderThreadImpl::current()->compositor_message_loop_proxy()
               ? RenderThreadImpl::current()->compositor_message_loop_proxy()
               : base::MessageLoopProxy::current()),
       compositor_(new VideoFrameCompositor(
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNaturalSizeChanged),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnOpacityChanged))),
       text_track_index_(0),
       encrypted_media_support_(EncryptedMediaPlayerSupport::Create(client)) {
   DCHECK(encrypted_media_support_);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   // |gpu_factories_| requires that its entry points be called on its
   // |GetTaskRunner()|.  Since |pipeline_| will own decoders created from the
   // factories, require that their message loops are identical.
   DCHECK(!gpu_factories_.get() ||
          (gpu_factories_->GetTaskRunner() == media_loop_.get()));
 
-  // Let V8 know we started new thread if we did not do it yet.
-  // Made separate task to avoid deletion of player currently being created.
-  // Also, delaying GC until after player starts gets rid of starting lag --
-  // collection happens in parallel with playing.
-  //
-  // TODO(enal): remove when we get rid of per-audio-stream thread.
-  main_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&WebMediaPlayerImpl::IncrementExternallyAllocatedMemory,
-                 AsWeakPtr()));
-
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink().get()
           ? params.audio_renderer_sink()
           : new media::NullAudioSink(media_loop_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   client_->setWebLayer(NULL);
 
@@ skipping 15 matching lines @@
   gpu_factories_ = NULL;
 
   // Make sure to kill the pipeline so there's no more media threads running.
   // Note: stopping the pipeline might block for a long time.
   base::WaitableEvent waiter(false, false);
   pipeline_.Stop(
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&waiter)));
   waiter.Wait();
 
   compositor_task_runner_->DeleteSoon(FROM_HERE, compositor_);
-
-  // Let V8 know we are not using extra resources anymore.
-  if (incremented_externally_allocated_memory_) {
-    v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
-        -kPlayerExtraMemory);
-    incremented_externally_allocated_memory_ = false;
-  }
 }
 
 void WebMediaPlayerImpl::load(LoadType load_type, const blink::WebURL& url,
                               CORSMode cors_mode) {
   DVLOG(1) << __FUNCTION__ << "(" << load_type << ", " << url << ", "
            << cors_mode << ")";
   if (!defer_load_cb_.is_null()) {
     defer_load_cb_.Run(base::Bind(
         &WebMediaPlayerImpl::DoLoad, AsWeakPtr(), load_type, url, cors_mode));
     return;
@@ skipping 715 matching lines @@
 
   ready_state_ = state;
   // Always notify to ensure client has the latest value.
   client_->readyStateChanged();
 }
 
 blink::WebAudioSourceProvider* WebMediaPlayerImpl::audioSourceProvider() {
   return audio_source_provider_.get();
 }
 
-void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
-  DCHECK(main_loop_->BelongsToCurrentThread());
-  incremented_externally_allocated_memory_ = true;
-  v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
-      kPlayerExtraMemory);
-}
-
 double WebMediaPlayerImpl::GetPipelineDuration() const {
   base::TimeDelta duration = pipeline_.GetMediaDuration();
 
   // Return positive infinity if the resource is unbounded.
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/video.html#dom-media-duration
   if (duration == media::kInfiniteDuration())
     return std::numeric_limits<double>::infinity();
 
   return duration.InSecondsF();
 }
@@ skipping 57 matching lines @@
   compositor_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&GetCurrentFrameAndSignal,
                                                base::Unretained(compositor_),
                                                &video_frame,
                                                &event));
   event.Wait();
   return video_frame;
 }
 
 }  // namespace content