Provide renderers with memory pressure signals.

content/browser/memory/memory_pressure_controller_impl_browsertest.cc

 // 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 "base/bind.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "content/browser/memory/memory_message_filter.h"
-#include "content/browser/memory/memory_pressure_controller.h"
+#include "content/browser/memory/memory_pressure_controller_impl.h"
 #include "content/common/memory_messages.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "ipc/ipc_message.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace content {
 
 MATCHER_P(IsSetSuppressedMessage, suppressed, "") {
@@ skipping 63 matching lines @@
       return;
     }
     OnChannelClosing();
     OnFilterRemoved();
   }
 
  protected:
   ~MemoryMessageFilterForTesting() override {}
 };
 
-class MemoryPressureControllerBrowserTest : public ContentBrowserTest {
+class MemoryPressureControllerImplBrowserTest : public ContentBrowserTest {
  public:
   MOCK_METHOD1(OnMemoryPressure,
                void(base::MemoryPressureListener::MemoryPressureLevel level));
 
  protected:
   void SetPressureNotificationsSuppressedInAllProcessesAndWait(
       bool suppressed) {
-    MemoryPressureController::GetInstance()
+    MemoryPressureControllerImpl::GetInstance()
         ->SetPressureNotificationsSuppressedInAllProcesses(suppressed);
     RunAllPendingInMessageLoop(BrowserThread::IO);
   }
 
   void SimulatePressureNotificationInAllProcessesAndWait(
       base::MemoryPressureListener::MemoryPressureLevel level) {
-    MemoryPressureController::GetInstance()
+    MemoryPressureControllerImpl::GetInstance()
         ->SimulatePressureNotificationInAllProcesses(level);
     RunAllPendingInMessageLoop(BrowserThread::IO);
   }
 
   void SendPressureNotificationAndWait(
       const void* fake_process_host,
       base::MemoryPressureListener::MemoryPressureLevel level) {
-    MemoryPressureController::GetInstance()->SendPressureNotification(
+    MemoryPressureControllerImpl::GetInstance()->SendPressureNotification(
         reinterpret_cast<const RenderProcessHost*>(fake_process_host), level);
     RunAllPendingInMessageLoop(BrowserThread::IO);
   }
 };
 
 const auto MEMORY_PRESSURE_LEVEL_MODERATE =
     base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
 const auto MEMORY_PRESSURE_LEVEL_CRITICAL =
     base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
 
-IN_PROC_BROWSER_TEST_F(MemoryPressureControllerBrowserTest,
+IN_PROC_BROWSER_TEST_F(MemoryPressureControllerImplBrowserTest,
                        SetPressureNotificationsSuppressedInAllProcesses) {
   scoped_refptr<MemoryMessageFilterForTesting> filter1(
       new MemoryMessageFilterForTesting);
   scoped_refptr<MemoryMessageFilterForTesting> filter2(
       new MemoryMessageFilterForTesting);
 
   NavigateToURL(shell(), GetTestUrl("", "title.html"));
 
   // Add the first filter. No messages should be sent because notifications are
   // not suppressed.
@@ skipping 68 matching lines @@
   // Remove the second filter and disable suppressing memory pressure
   // notifications in all processes. No messages should be sent.
   EXPECT_CALL(*filter1, Send(testing::_)).Times(0);
   EXPECT_CALL(*filter2, Send(testing::_)).Times(0);
   filter2->Remove();
   SetPressureNotificationsSuppressedInAllProcessesAndWait(false);
   EXPECT_FALSE(base::MemoryPressureListener::AreNotificationsSuppressed());
   testing::Mock::VerifyAndClearExpectations(this);
 }
 
-IN_PROC_BROWSER_TEST_F(MemoryPressureControllerBrowserTest,
+IN_PROC_BROWSER_TEST_F(MemoryPressureControllerImplBrowserTest,
                        SimulatePressureNotificationInAllProcesses) {
   scoped_refptr<MemoryMessageFilterForTesting> filter(
       new MemoryMessageFilterForTesting);
   scoped_ptr<base::MemoryPressureListener> listener(
       new base::MemoryPressureListener(
-          base::Bind(&MemoryPressureControllerBrowserTest::OnMemoryPressure,
+          base::Bind(&MemoryPressureControllerImplBrowserTest::OnMemoryPressure,
                      base::Unretained(this))));
 
   NavigateToURL(shell(), GetTestUrl("", "title.html"));
 
   filter->Add();
 
   // Send a memory pressure event to the first child process. It should send a
   // pressure notification message.
   EXPECT_CALL(*filter, Send(IsPressureMessage(MEMORY_PRESSURE_LEVEL_MODERATE)))
       .Times(1);
@@ skipping 33 matching lines @@
   EXPECT_CALL(*this, OnMemoryPressure(MEMORY_PRESSURE_LEVEL_MODERATE)).Times(1);
   SimulatePressureNotificationInAllProcessesAndWait(
       MEMORY_PRESSURE_LEVEL_MODERATE);
   RunAllPendingInMessageLoop();  // Wait for the listener to run.
   testing::Mock::VerifyAndClearExpectations(this);
 
   filter->Remove();
 }
 
 }  // namespace content