[Test] Move DelegatedFrameEvictor into components -public_deps

content/browser/renderer_host/render_widget_host_view_aura_unittest.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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <tuple>
@@ skipping 92 matching lines @@
 
 using testing::_;
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using ui::WebInputEventTraits;
+using viz::FrameEvictionManager;
 
 namespace content {
 
 void InstallDelegatedFrameHostClient(
     RenderWidgetHostViewAura* render_widget_host_view,
     std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client);
 
 namespace {
 
 const cc::LocalSurfaceId kArbitraryLocalSurfaceId(
@@ skipping 524 matching lines @@
 
   void TearDown() override { TearDownEnvironment(); }
 
   void set_widget_host_uses_shutdown_to_destroy(bool use) {
     widget_host_uses_shutdown_to_destroy_ = use;
   }
 
   void SimulateMemoryPressure(
       base::MemoryPressureListener::MemoryPressureLevel level) {
     // Here should be base::MemoryPressureListener::NotifyMemoryPressure, but
-    // since the RendererFrameManager is installing a MemoryPressureListener
+    // since the FrameEvictionManager is installing a MemoryPressureListener
     // which uses base::ObserverListThreadSafe, which furthermore remembers the
     // message loop for the thread it was created in. Between tests, the
-    // RendererFrameManager singleton survives and and the MessageLoop gets
+    // FrameEvictionManager singleton survives and and the MessageLoop gets
     // destroyed. The correct fix would be to have base::ObserverListThreadSafe
     // look
     // up the proper message loop every time (see crbug.com/443824.)
-    RendererFrameManager::GetInstance()->OnMemoryPressure(level);
+    FrameEvictionManager::GetInstance()->OnMemoryPressure(level);
   }
 
   void SendInputEventACK(WebInputEvent::Type type,
       InputEventAckState ack_result) {
     DCHECK(!WebInputEvent::IsTouchEventType(type));
     InputEventAck ack(InputEventAckSource::COMPOSITOR_THREAD, type, ack_result);
     InputHostMsg_HandleInputEvent_ACK response(0, ack);
     widget_host_->OnMessageReceived(response);
   }
 
@@ skipping 1977 matching lines @@
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   view_->window_->RemoveObserver(&observer);
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, DiscardDelegatedFrames) {
   view_->InitAsChild(nullptr);
 
   size_t max_renderer_frames =
-      RendererFrameManager::GetInstance()->GetMaxNumberOfSavedFrames();
+      FrameEvictionManager::GetInstance()->GetMaxNumberOfSavedFrames();
   ASSERT_LE(2u, max_renderer_frames);
   size_t renderer_count = max_renderer_frames + 1;
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
   DCHECK_EQ(0u, display_compositor::HostSharedBitmapManager::current()
                     ->AllocatedBitmapCount());
 
   std::unique_ptr<RenderWidgetHostImpl* []> hosts(
       new RenderWidgetHostImpl*[renderer_count]);
   std::unique_ptr<FakeRenderWidgetHostViewAura* []> views(
@@ skipping 122 matching lines @@
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, size2, gfx::Rect(size2)));
   EXPECT_FALSE(views[1]->released_front_lock_active());
 
   for (size_t i = 0; i < renderer_count - 1; ++i)
     views[i]->Hide();
 
   // Allocate enough bitmaps so that two frames (proportionally) would be
   // enough hit the handle limit.
   int handles_per_frame = 5;
-  RendererFrameManager::GetInstance()->set_max_handles(handles_per_frame * 2);
+  FrameEvictionManager::GetInstance()->set_max_handles(handles_per_frame * 2);
 
   display_compositor::HostSharedBitmapManagerClient bitmap_client(
       display_compositor::HostSharedBitmapManager::current());
 
   for (size_t i = 0; i < (renderer_count - 1) * handles_per_frame; i++) {
     bitmap_client.ChildAllocatedSharedBitmap(
         1, base::SharedMemory::NULLHandle(), cc::SharedBitmap::GenerateId());
   }
 
   // Hiding this last bitmap should evict all but two frames.
   views[renderer_count - 1]->Hide();
   for (size_t i = 0; i < renderer_count; ++i) {
     if (i + 2 < renderer_count)
       EXPECT_FALSE(views[i]->HasFrameData());
     else
       EXPECT_TRUE(views[i]->HasFrameData());
   }
-  RendererFrameManager::GetInstance()->set_max_handles(
+  FrameEvictionManager::GetInstance()->set_max_handles(
       base::SharedMemory::GetHandleLimit());
 
   for (size_t i = 0; i < renderer_count; ++i) {
     views[i]->Destroy();
     delete hosts[i];
   }
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, DiscardDelegatedFramesWithLocking) {
   view_->InitAsChild(nullptr);
 
   size_t max_renderer_frames =
-      RendererFrameManager::GetInstance()->GetMaxNumberOfSavedFrames();
+      FrameEvictionManager::GetInstance()->GetMaxNumberOfSavedFrames();
   ASSERT_LE(2u, max_renderer_frames);
   size_t renderer_count = max_renderer_frames + 1;
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
   DCHECK_EQ(0u, display_compositor::HostSharedBitmapManager::current()
                     ->AllocatedBitmapCount());
 
   std::unique_ptr<RenderWidgetHostImpl* []> hosts(
       new RenderWidgetHostImpl*[renderer_count]);
   std::unique_ptr<FakeRenderWidgetHostViewAura* []> views(
@@ skipping 51 matching lines @@
 
 // Test that changing the memory pressure should delete saved frames. This test
 // only applies to ChromeOS.
 TEST_F(RenderWidgetHostViewAuraTest, DiscardDelegatedFramesWithMemoryPressure) {
   view_->InitAsChild(nullptr);
 
   // The test logic below relies on having max_renderer_frames > 2.  By default,
   // this value is calculated from total physical memory and causes the test to
   // fail when run on hardware with < 256MB of RAM.
   const size_t kMaxRendererFrames = 5;
-  RendererFrameManager::GetInstance()->set_max_number_of_saved_frames(
+  FrameEvictionManager::GetInstance()->set_max_number_of_saved_frames(
       kMaxRendererFrames);
 
   size_t renderer_count = kMaxRendererFrames;
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
   DCHECK_EQ(0u, display_compositor::HostSharedBitmapManager::current()
                     ->AllocatedBitmapCount());
 
   std::unique_ptr<RenderWidgetHostImpl* []> hosts(
       new RenderWidgetHostImpl*[renderer_count]);
@@ skipping 2513 matching lines @@
     // There is no composition in the beginning.
     EXPECT_FALSE(has_composition_text());
     SetHasCompositionTextToTrue();
     view->ImeCancelComposition();
     // The composition must have been canceled.
     EXPECT_FALSE(has_composition_text());
   }
 }
 
 }  // namespace content