[Not for review] Discardable memory emulation

content/renderer/render_thread_impl.cc

 // Copyright (c) 2012 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/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/discardable_memory.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_table.h"
 #include "base/path_service.h"
 #include "base/shared_memory.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"  // Temporary
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 34 matching lines @@
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/audio_renderer_mixer_manager.h"
 #include "content/renderer/media/media_stream_center.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/video_capture_message_filter.h"
 #include "content/renderer/memory_benchmarking_extension.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/plugin_channel_host.h"
+#include "content/renderer/render_process_discardable_memory_provider.h"
 #include "content/renderer/render_process_impl.h"
+#include "content/renderer/render_process_visibility_manager.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
 #include "content/renderer/skia_benchmarking_extension.h"
 #include "grit/content_resources.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_forwarding_message_filter.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/media.h"
 #include "net/base/net_errors.h"
@@ skipping 311 matching lines @@
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kEnableGpuBenchmarking))
       RegisterExtension(GpuBenchmarkingExtension::Get());
 
 #if defined(USE_TCMALLOC) && (defined(OS_LINUX) || defined(OS_ANDROID))
   if (command_line.HasSwitch(switches::kEnableMemoryBenchmarking))
     RegisterExtension(MemoryBenchmarkingExtension::Get());
 #endif  // USE_TCMALLOC
 
+  if (!base::DiscardableMemoryProvider::GetInstance()) {

[Avi (use Gerrit), 2013/06/07 14:46:53]

DISCARDABLE_MEMORY_SUPPORTED_NATIVELY?

But only if we want to say in the .h that iff
DISCARDABLE_MEMORY_SUPPORTED_NATIVELY then GetInstance is guaranteed to succeed.
Which might not be true if we decide to have a Win8 impl.

+    discardable_provider_.reset(new RenderProcessDiscardableMemoryProvider);
+    RenderProcessVisibilityManager::GetInstance()->AddObserver(
+        discardable_provider_.get());
+    base::DiscardableMemoryProvider::SetInstance(discardable_provider_.get());
+  }
+
   if (command_line.HasSwitch(switches::kEnableSkiaBenchmarking)) {
     LOG(WARNING) << "Enabling unsafe Skia benchmarking extension.";
     RegisterExtension(SkiaBenchmarkingExtension::Get());
   }
 
   context_lost_cb_.reset(new GpuVDAContextLostCallback());
 
   // Note that under Linux, the media library will normally already have
   // been initialized by the Zygote before this instance became a Renderer.
   base::FilePath media_path;
   PathService::Get(DIR_MEDIA_LIBS, &media_path);
   if (!media_path.empty())
     media::InitializeMediaLibrary(media_path);
 
   TRACE_EVENT_END_ETW("RenderThreadImpl::Init", 0, "");
 }
 
 RenderThreadImpl::~RenderThreadImpl() {
+  if (discardable_provider_)
+    base::DiscardableMemoryProvider::SetInstance(NULL);
 }
 
 void RenderThreadImpl::Shutdown() {
   FOR_EACH_OBSERVER(
       RenderProcessObserver, observers_, OnRenderProcessShutdown());
 
   // Wait for all databases to be closed.
   if (web_database_observer_impl_)
     web_database_observer_impl_->WaitForAllDatabasesToClose();
 
@@ skipping 179 matching lines @@
 
 void RenderThreadImpl::SetResourceDispatcherDelegate(
     ResourceDispatcherDelegate* delegate) {
   resource_dispatcher()->set_delegate(delegate);
 }
 
 void RenderThreadImpl::WidgetHidden() {
   DCHECK(hidden_widget_count_ < widget_count_);
   hidden_widget_count_++;
 
+  if (discardable_provider_) {
+    RenderProcessVisibilityManager* manager =
+        RenderProcessVisibilityManager::GetInstance();
+    manager->WidgetVisibilityChanged(false);
+  }
+
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   if (widget_count_ && hidden_widget_count_ == widget_count_)
     ScheduleIdleHandler(kInitialIdleHandlerDelayMs);
 }
 
 void RenderThreadImpl::WidgetRestored() {
   DCHECK_GT(hidden_widget_count_, 0);
   hidden_widget_count_--;
+
+  if (discardable_provider_) {
+    RenderProcessVisibilityManager* manager =
+        RenderProcessVisibilityManager::GetInstance();
+    manager->WidgetVisibilityChanged(true);
+  }
+
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 static void AdjustRuntimeFeatureDefaultsForPlatform() {
 #if defined(OS_ANDROID) && !defined(GOOGLE_TV)
   WebRuntimeFeatures::enableWebKitMediaSource(false);
@@ skipping 691 matching lines @@
 
 void RenderThreadImpl::SetFlingCurveParameters(
     const std::vector<float>& new_touchpad,
     const std::vector<float>& new_touchscreen) {
   webkit_platform_support_->SetFlingCurveParameters(new_touchpad,
                                                     new_touchscreen);
 
 }
 
 }  // namespace content