Make purge+throttled feature work with memory coordinator

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 <utility>
@@ skipping 797 matching lines @@
     media::EnablePlatformDecoderSupport();
   }
 #endif
 
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&RenderThreadImpl::OnMemoryPressure, base::Unretained(this)),
       base::Bind(&RenderThreadImpl::OnSyncMemoryPressure,
                  base::Unretained(this))));
 
   if (base::FeatureList::IsEnabled(features::kMemoryCoordinator)) {
-    // Currently it is not possible to enable both PurgeAndSuspend and
-    // MemoryCoordinator at the same time.
-    DCHECK(!base::FeatureList::IsEnabled(features::kPurgeAndSuspend));
-
     // Disable MemoryPressureListener when memory coordinator is enabled.
     base::MemoryPressureListener::SetNotificationsSuppressed(true);
 
     // TODO(bashi): Revisit how to manage the lifetime of
     // ChildMemoryCoordinatorImpl.
     // https://codereview.chromium.org/2094583002/#msg52
     mojom::MemoryCoordinatorHandlePtr parent_coordinator;
     GetRemoteInterfaces()->GetInterface(mojo::MakeRequest(&parent_coordinator));
     memory_coordinator_ = CreateChildMemoryCoordinator(
         std::move(parent_coordinator), this);
@@ skipping 795 matching lines @@
 }
 
 void RenderThreadImpl::OnProcessBackgrounded(bool backgrounded) {
   ChildThreadImpl::OnProcessBackgrounded(backgrounded);
 
   if (backgrounded) {
     renderer_scheduler_->OnRendererBackgrounded();
     needs_to_record_first_active_paint_ = false;
   } else {
     renderer_scheduler_->OnRendererForegrounded();
-    // TODO(tasak): after enabling MemoryCoordinator, remove this Notify
-    // and follow MemoryCoordinator's request.
-    if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend))
-      base::MemoryCoordinatorClientRegistry::GetInstance()->Notify(
-          base::MemoryState::NORMAL);
 
     record_purge_suspend_metric_closure_.Cancel();
     record_purge_suspend_metric_closure_.Reset(
         base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMetrics,
                    base::Unretained(this)));
     record_purge_suspend_growth_metric_closure_.Cancel();
     record_purge_suspend_growth_metric_closure_.Reset(
         base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics,
                    base::Unretained(this)));
   }
 }
 
 void RenderThreadImpl::OnProcessPurgeAndSuspend() {
   ChildThreadImpl::OnProcessPurgeAndSuspend();
   if (!RendererIsHidden())
     return;
 
-  // TODO(bashi): Enable the tab suspension when MemoryCoordinator is enabled.
-  if (base::FeatureList::IsEnabled(features::kMemoryCoordinator))
-    return;
-
   if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend)) {
-    // TODO(tasak): After enabling MemoryCoordinator, remove this Notify
-    // and follow MemoryCoordinator's request.
     base::MemoryCoordinatorClientRegistry::GetInstance()->PurgeMemory();
   }
   // Since purging is not a synchronous task (e.g. v8 GC, oilpan GC, ...),
   // we need to wait until the task is finished. So wait 15 seconds and
   // update purge+suspend UMA histogram.
   // TODO(tasak): use MemoryCoordinator's callback to report purge+suspend
   // UMA when MemoryCoordinator is available.
   GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask(
       FROM_HERE, record_purge_suspend_metric_closure_.callback(),
       base::TimeDelta::FromSeconds(15));
@@ skipping 152 matching lines @@
   UMA_HISTOGRAM_MEMORY_KB(
       "PurgeAndSuspend.Experimental.MemoryGrowth.V8MainThreadIsolateKB",
       GET_MEMORY_GROWTH(memory_metrics, purge_and_suspend_memory_metrics_,
                         v8_main_thread_isolate_mb) * 1024);
   UMA_HISTOGRAM_MEMORY_KB(
       "PurgeAndSuspend.Experimental.MemoryGrowth.TotalAllocatedKB",
       GET_MEMORY_GROWTH(memory_metrics, purge_and_suspend_memory_metrics_,
                         total_allocated_mb) * 1024);
 }
 
-void RenderThreadImpl::OnProcessResume() {
-  ChildThreadImpl::OnProcessResume();
-
-  if (!RendererIsHidden())
-    return;
-
-  // TODO(bashi): Enable the tab suspension when MemoryCoordinator is enabled.
-  if (base::FeatureList::IsEnabled(features::kMemoryCoordinator))
-    return;
-
-  if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend)) {
-    // TODO(tasak): after enabling MemoryCoordinator, remove this Notify
-    // and follow MemoryCoordinator's request.
-    base::MemoryCoordinatorClientRegistry::GetInstance()->Notify(
-        base::MemoryState::NORMAL);
-  }
-}
-
 scoped_refptr<gpu::GpuChannelHost> RenderThreadImpl::EstablishGpuChannelSync() {
   TRACE_EVENT0("gpu", "RenderThreadImpl::EstablishGpuChannelSync");
 
   if (gpu_channel_) {
     // Do nothing if we already have a GPU channel or are already
     // establishing one.
     if (!gpu_channel_->IsLost())
       return gpu_channel_;
 
     // Recreate the channel if it has been lost.
@@ skipping 547 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content