Enforce constant size and device scale factor for surfaces

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>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
+#include "cc/surfaces/local_surface_id_allocator.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_external_begin_frame_source.h"
 #include "components/viz/display_compositor/gl_helper.h"
 #include "components/viz/display_compositor/host_shared_bitmap_manager.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/compositor/test/no_transport_image_transport_factory.h"
 #include "content/browser/frame_host/render_widget_host_view_guest.h"
 #include "content/browser/gpu/compositor_util.h"
@@ skipping 83 matching lines @@
 void InstallDelegatedFrameHostClient(
     RenderWidgetHostViewAura* render_widget_host_view,
     std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client);
 
 namespace {
 
 const cc::LocalSurfaceId kArbitraryLocalSurfaceId(
     1,
     base::UnguessableToken::Deserialize(2, 3));
 
-cc::LocalSurfaceId CreateLocalSurfaceId() {
-  return cc::LocalSurfaceId(1, base::UnguessableToken::Create());
-}
-
 class TestOverscrollDelegate : public OverscrollControllerDelegate {
  public:
   explicit TestOverscrollDelegate(RenderWidgetHostView* view)
       : view_(view),
         current_mode_(OVERSCROLL_NONE),
         completed_mode_(OVERSCROLL_NONE),
         delta_x_(0.f),
         delta_y_(0.f) {}
 
   ~TestOverscrollDelegate() override {}
@@ skipping 671 matching lines @@
   RenderWidgetHostViewAura* parent_view_;
 
   // Tests should set these to nullptr if they've already triggered their
   // destruction.
   MockRenderWidgetHostImpl* widget_host_;
   FakeRenderWidgetHostViewAura* view_;
 
   IPC::TestSink* sink_;
   base::test::ScopedFeatureList feature_list_;
 
+  cc::LocalSurfaceIdAllocator local_surface_id_allocator_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraTest);
 };
 
 class RenderWidgetHostViewAuraRafAlignedTouchEnabledTest
     : public RenderWidgetHostViewAuraTest {
  public:
   void SetUp() override {
     EnableRafAlignedTouchInput();
     RenderWidgetHostViewAuraTest::SetUp();
@@ skipping 1265 matching lines @@
   resource.id = 1;
   frame.resource_list.push_back(resource);
   view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
   EXPECT_EQ(0u, sink_->message_count());
 
   // Signal that a new RendererCompositorFrameSink was created by the renderer.
   view_->CreateNewRendererCompositorFrameSink();
 
   // Submit another frame. The resources for the previous frame belong to the
   // old RendererCompositorFrameSink and should not be returned.
-  view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
+  view_->SubmitCompositorFrame(local_surface_id_allocator_.GenerateId(),
                                MakeDelegatedFrame(1.f, view_size, view_rect));
   EXPECT_EQ(0u, sink_->message_count());
 
   // Report that the surface is drawn to trigger an ACK.
   view_->renderer_compositor_frame_sink_->Reset();
   cc::Surface* surface = manager->GetSurfaceForId(view_->surface_id());
   EXPECT_TRUE(surface);
   surface->RunDrawCallback();
   view_->renderer_compositor_frame_sink_->Flush();
   EXPECT_TRUE(view_->renderer_compositor_frame_sink_->did_receive_ack());
@@ skipping 125 matching lines @@
     root->layer()->Remove(mirror->root());
   }
 }
 
 // If the view size is larger than the compositor frame then extra layers
 // should be created to fill the gap.
 TEST_F(RenderWidgetHostViewAuraTest, DelegatedFrameGutter) {
   gfx::Size large_size(100, 100);
   gfx::Size small_size(40, 45);
   gfx::Size medium_size(40, 95);
+  cc::LocalSurfaceId small_id = local_surface_id_allocator_.GenerateId();
+  cc::LocalSurfaceId medium_id = local_surface_id_allocator_.GenerateId();
 
   // Prevent the DelegatedFrameHost from skipping frames.
   // XXX
   view_->DisableResizeLock();
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(large_size);
   view_->Show();
   cc::CompositorFrame frame =
       MakeDelegatedFrame(1.f, small_size, gfx::Rect(small_size));
   frame.metadata.root_background_color = SK_ColorRED;
-  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
+  view_->SubmitCompositorFrame(small_id, std::move(frame));
 
   ui::Layer* parent_layer = view_->GetNativeView()->layer();
 
   ASSERT_EQ(2u, parent_layer->children().size());
   EXPECT_EQ(gfx::Rect(40, 0, 60, 100), parent_layer->children()[0]->bounds());
   EXPECT_EQ(SK_ColorRED, parent_layer->children()[0]->background_color());
   EXPECT_EQ(gfx::Rect(0, 45, 40, 55), parent_layer->children()[1]->bounds());
   EXPECT_EQ(SK_ColorRED, parent_layer->children()[1]->background_color());
 
   delegates_.back()->set_is_fullscreen(true);
   view_->SetSize(medium_size);
 
   // Right gutter is unnecessary.
   ASSERT_EQ(1u, parent_layer->children().size());
   EXPECT_EQ(gfx::Rect(0, 45, 40, 50), parent_layer->children()[0]->bounds());
 
   // RWH is fullscreen, so gutters should be black.
   EXPECT_EQ(SK_ColorBLACK, parent_layer->children()[0]->background_color());
 
   frame = MakeDelegatedFrame(1.f, medium_size, gfx::Rect(medium_size));
-  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
+  view_->SubmitCompositorFrame(medium_id, std::move(frame));
   EXPECT_EQ(0u, parent_layer->children().size());
 
   view_->SetSize(large_size);
   ASSERT_EQ(2u, parent_layer->children().size());
 
   // This should evict the frame and remove the gutter layers.
   view_->Hide();
   view_->SetSize(small_size);
   ASSERT_EQ(0u, parent_layer->children().size());
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, Resize) {
   gfx::Size size1(100, 100);
   gfx::Size size2(200, 200);
   gfx::Size size3(300, 300);
+  cc::LocalSurfaceId id1 = local_surface_id_allocator_.GenerateId();
+  cc::LocalSurfaceId id2 = local_surface_id_allocator_.GenerateId();
+  cc::LocalSurfaceId id3 = local_surface_id_allocator_.GenerateId();
 
   aura::Window* root_window = parent_view_->GetNativeView()->GetRootWindow();
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), root_window, gfx::Rect(size1));
   view_->Show();
   view_->SetSize(size1);
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, size1, gfx::Rect(size1)));
+      id1, MakeDelegatedFrame(1.f, size1, gfx::Rect(size1)));
   ui::DrawWaiterForTest::WaitForCommit(
       root_window->GetHost()->compositor());
   ViewHostMsg_UpdateRect_Params update_params;
   update_params.view_size = size1;
   update_params.flags = ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
   widget_host_->OnMessageReceived(
       ViewHostMsg_UpdateRect(widget_host_->GetRoutingID(), update_params));
   sink_->ClearMessages();
   // Resize logic is idle (no pending resize, no pending commit).
   EXPECT_EQ(size1.ToString(), view_->GetRequestedRendererSize().ToString());
@@ skipping 18 matching lines @@
   // Resize renderer again, before receiving a frame. Should not produce a
   // Resize message.
   view_->SetSize(size3);
   EXPECT_EQ(size2.ToString(), view_->GetRequestedRendererSize().ToString());
   EXPECT_EQ(0u, sink_->message_count());
 
   // Receive a frame of the new size, should be skipped and not produce a Resize
   // message.
   view_->renderer_compositor_frame_sink_->Reset();
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, size3, gfx::Rect(size3)));
+      id3, MakeDelegatedFrame(1.f, size3, gfx::Rect(size3)));
   view_->renderer_compositor_frame_sink_->Flush();
   // Expect the frame ack;
   EXPECT_TRUE(view_->renderer_compositor_frame_sink_->did_receive_ack());
   EXPECT_EQ(size2.ToString(), view_->GetRequestedRendererSize().ToString());
 
   // Receive a frame of the correct size, should not be skipped and, and should
   // produce a Resize message after the commit.
   view_->renderer_compositor_frame_sink_->Reset();
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, size2, gfx::Rect(size2)));
+      id2, MakeDelegatedFrame(1.f, size2, gfx::Rect(size2)));
   view_->renderer_compositor_frame_sink_->Flush();
   cc::SurfaceId surface_id = view_->surface_id();
   if (!surface_id.is_valid()) {
     // No frame ack yet.
     EXPECT_FALSE(view_->renderer_compositor_frame_sink_->did_receive_ack());
   } else {
     // Frame isn't desired size, so early ack.
     EXPECT_TRUE(view_->renderer_compositor_frame_sink_->did_receive_ack());
   }
   EXPECT_EQ(size2.ToString(), view_->GetRequestedRendererSize().ToString());
@@ skipping 36 matching lines @@
   update_params.view_size = size3;
   widget_host_->OnMessageReceived(
       ViewHostMsg_UpdateRect(widget_host_->GetRoutingID(), update_params));
   sink_->ClearMessages();
 }
 
 // Skipped frames should not drop their damage.
 TEST_F(RenderWidgetHostViewAuraTest, SkippedDelegatedFrames) {
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
+  cc::LocalSurfaceId local_surface_id = kArbitraryLocalSurfaceId;
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(view_rect.size());
 
   MockWindowObserver observer;
   view_->window_->AddObserver(&observer);
 
   // A full frame of damage.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(local_surface_id,
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // A partial damage frame.
   gfx::Rect partial_view_rect(30, 30, 20, 20);
   EXPECT_CALL(observer,
               OnDelegatedFrameDamage(view_->window_, partial_view_rect));
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, frame_size, partial_view_rect));
+      local_surface_id, MakeDelegatedFrame(1.f, frame_size, partial_view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   EXPECT_FALSE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
 
   // Lock the compositor. Now we should drop frames.
   view_rect = gfx::Rect(150, 150);
   view_->SetSize(view_rect.size());
   EXPECT_TRUE(view_->resize_locked());
   EXPECT_TRUE(view_->compositor_locked());
 
   // This frame is dropped.
   gfx::Rect dropped_damage_rect_1(10, 20, 30, 40);
   EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
+      local_surface_id,
       MakeDelegatedFrame(1.f, frame_size, dropped_damage_rect_1));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   gfx::Rect dropped_damage_rect_2(40, 50, 10, 20);
   EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
+      local_surface_id,
       MakeDelegatedFrame(1.f, frame_size, dropped_damage_rect_2));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   EXPECT_TRUE(view_->resize_locked());
   EXPECT_TRUE(view_->compositor_locked());
 
   // Unlock the compositor. This frame should damage everything.
   frame_size = view_rect.size();
+  local_surface_id = local_surface_id_allocator_.GenerateId();
 
   gfx::Rect new_damage_rect(5, 6, 10, 10);
   EXPECT_CALL(observer,
               OnDelegatedFrameDamage(view_->window_, view_rect));
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, frame_size, new_damage_rect));
+      local_surface_id, MakeDelegatedFrame(1.f, frame_size, new_damage_rect));
   // The swap unlocks the compositor.
   EXPECT_TRUE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
   testing::Mock::VerifyAndClearExpectations(&observer);
   // The UI commit unlocks for further resize.
   view_->RunOnCompositingDidCommit();
   EXPECT_FALSE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
 
   // A partial damage frame, this should not be dropped.
   EXPECT_CALL(observer,
               OnDelegatedFrameDamage(view_->window_, partial_view_rect));
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, frame_size, partial_view_rect));
+      local_surface_id, MakeDelegatedFrame(1.f, frame_size, partial_view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
   EXPECT_FALSE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
 
   // Resize to something empty. This doesn't lock anything since it's not
   // visible anymore anyways.
   view_rect = gfx::Rect(100, 0);
   view_->SetSize(view_rect.size());
   EXPECT_FALSE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
 
   // We're never expecting empty frames, resize to something non-empty.
   view_rect = gfx::Rect(100, 100);
+  frame_size = view_rect.size();
+  local_surface_id = local_surface_id_allocator_.GenerateId();
   view_->SetSize(view_rect.size());
   EXPECT_TRUE(view_->resize_locked());
   EXPECT_TRUE(view_->compositor_locked());
 
   // This frame should not be dropped.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, view_rect.size(), view_rect));
+  view_->SubmitCompositorFrame(local_surface_id,
+                               MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   EXPECT_TRUE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
   view_->RunOnCompositingDidCommit();
   EXPECT_FALSE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
 
   view_->window_->RemoveObserver(&observer);
 }
 
 // If resize races with a renderer frame, we should lock for the right size.
 TEST_F(RenderWidgetHostViewAuraTest, ResizeAfterReceivingFrame) {
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
+  cc::LocalSurfaceId local_surface_id = kArbitraryLocalSurfaceId;
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(view_rect.size());
 
   MockWindowObserver observer;
   view_->window_->AddObserver(&observer);
 
   // A frame of initial size.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
+      local_surface_id,
       MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // A frame of initial size arrives, but we don't commit in the UI yet.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, _));
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
+      local_surface_id,
       MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
   testing::Mock::VerifyAndClearExpectations(&observer);
 
   EXPECT_FALSE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
 
   // Resize, and lock the compositor. Now we should drop frames of the old size.
   view_rect = gfx::Rect(150, 150);
   view_->SetSize(view_rect.size());
   EXPECT_TRUE(view_->resize_locked());
   EXPECT_TRUE(view_->compositor_locked());
 
   EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
+      local_surface_id,
       MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
   testing::Mock::VerifyAndClearExpectations(&observer);
 
   // If the CompositorLock times out in the meantime, a commit would happen.
   // Verify that if a commit occurs, the lock remains and we reject frames
   // of the wrong size still.
   view_->RunOnCompositingDidCommit();
 
   EXPECT_TRUE(view_->resize_locked());
   // In this case we lied about it and the CompositorLock is still active.
   EXPECT_TRUE(view_->compositor_locked());
 
   EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
+      local_surface_id,
       MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
   testing::Mock::VerifyAndClearExpectations(&observer);
 
   // A frame arrives of the new size, which will be accepted.
   frame_size = view_rect.size();
+  local_surface_id = local_surface_id_allocator_.GenerateId();
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, _));
   view_->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
+      local_surface_id,
       MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
   // Receiving the frame unlocks the compositor so it can commit.
   EXPECT_TRUE(view_->resize_locked());
   EXPECT_FALSE(view_->compositor_locked());
   testing::Mock::VerifyAndClearExpectations(&observer);
 
   // When the frame of the correct size is committed, the CompositorResizeLock
   // is released.
   view_->RunOnCompositingDidCommit();
   EXPECT_FALSE(view_->resize_locked());
@@ skipping 70 matching lines @@
   view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId,
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // Signal that a new RendererCompositorFrameSink was created.
   view_->CreateNewRendererCompositorFrameSink();
 
   // Submit a frame from the new RendererCompositorFrameSink.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
+  view_->SubmitCompositorFrame(local_surface_id_allocator_.GenerateId(),
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // Signal that a new RendererCompositorFrameSink was created.
   view_->CreateNewRendererCompositorFrameSink();
 
   // Submit a frame from the new RendererCompositorFrameSink.
   view_->SubmitCompositorFrame(
-      CreateLocalSurfaceId(),
+      local_surface_id_allocator_.GenerateId(),
       MakeDelegatedFrame(1.f, gfx::Size(), gfx::Rect()));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // Signal that a new RendererCompositorFrameSink was created.
   view_->CreateNewRendererCompositorFrameSink();
 
   // Swap another frame, with a different surface id.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
+  view_->SubmitCompositorFrame(local_surface_id_allocator_.GenerateId(),
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   view_->window_->RemoveObserver(&observer);
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, DiscardDelegatedFrames) {
   view_->InitAsChild(nullptr);
 
@@ skipping 118 matching lines @@
   views[0]->Show();
   EXPECT_TRUE(views[0]->released_front_lock_active());
   // Make [0] hidden, it should stop waiting.
   views[0]->Hide();
   EXPECT_FALSE(views[0]->released_front_lock_active());
 
   // Make [1] hidden, resize it. It should drop its frame.
   views[1]->Hide();
   EXPECT_TRUE(views[1]->HasFrameData());
   gfx::Size size2(200, 200);
+  cc::LocalSurfaceId id2 = local_surface_id_allocator_.GenerateId();
   views[1]->SetSize(size2);
   EXPECT_FALSE(views[1]->HasFrameData());
   // Show it, it should block until we give it a frame.
   views[1]->Show();
   EXPECT_TRUE(views[1]->released_front_lock_active());
   views[1]->SubmitCompositorFrame(
-      kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, size2, gfx::Rect(size2)));
+      id2, 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;
   FrameEvictionManager::GetInstance()->set_max_handles(handles_per_frame * 2);
 
@@ skipping 54 matching lines @@
         parent_view_->GetNativeView()->GetRootWindow(),
         gfx::Rect());
     views[i]->SetSize(view_rect.size());
   }
 
   // Make each renderer visible and swap a frame on it. No eviction should
   // occur because all frames are visible.
   for (size_t i = 0; i < renderer_count; ++i) {
     views[i]->Show();
     views[i]->SubmitCompositorFrame(
-        i ? CreateLocalSurfaceId() : kArbitraryLocalSurfaceId,
+        i ? local_surface_id_allocator_.GenerateId() : kArbitraryLocalSurfaceId,
         MakeDelegatedFrame(1.f, frame_size, view_rect));
     EXPECT_TRUE(views[i]->HasFrameData());
   }
 
   // If we hide [0], then [0] should be evicted.
   views[0]->Hide();
   EXPECT_FALSE(views[0]->HasFrameData());
 
   // If we lock [0] before hiding it, then [0] should not be evicted.
   views[0]->Show();
@@ skipping 125 matching lines @@
   cc::BeginFrameObserver* last_observer_ = nullptr;
 };
 }  // namespace
 
 // Tests that BeginFrameAcks are forwarded correctly from the
 // SwapCompositorFrame and OnBeginFrameDidNotSwap IPCs through
 // DelegatedFrameHost and its CompositorFrameSinkSupport.
 TEST_F(RenderWidgetHostViewAuraTest, ForwardsBeginFrameAcks) {
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
+  cc::LocalSurfaceId local_surface_id = kArbitraryLocalSurfaceId;
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(view_rect.size());
 
   // Replace BeginFrameSource so that we can observe acknowledgments. Since the
   // DelegatedFrameHost doesn't directly observe our BeginFrameSource,
   // |observer_tracker| grabs a pointer to the observer (the
@@ skipping 13 matching lines @@
 
   {
     cc::BeginFrameArgs args =
         cc::CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, source_id, 5u);
     source.TestOnBeginFrame(args);
 
     // Ack from CompositorFrame is forwarded.
     cc::BeginFrameAck ack(source_id, 5, 4, true);
     cc::CompositorFrame frame = MakeDelegatedFrame(1.f, frame_size, view_rect);
     frame.metadata.begin_frame_ack = ack;
-    view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
+    view_->SubmitCompositorFrame(local_surface_id, std::move(frame));
     view_->RunOnCompositingDidCommit();
     EXPECT_EQ(ack, source.LastAckForObserver(observer_tracker.last_observer_));
   }
 
   {
     cc::BeginFrameArgs args =
         cc::CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, source_id, 6u);
     source.TestOnBeginFrame(args);
 
     // Explicit ack through OnBeginFrameDidNotSwap is forwarded.
@@ skipping 12 matching lines @@
         cc::CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, source_id, 7u);
     source.TestOnBeginFrame(args);
 
     // Ack from CompositorFrame is forwarded with old
     // latest_confirmed_sequence_number and without damage.
     cc::BeginFrameAck ack(source_id, 7, 7, true);
     gfx::Rect dropped_damage_rect(10, 20, 30, 40);
     cc::CompositorFrame frame =
         MakeDelegatedFrame(1.f, frame_size, dropped_damage_rect);
     frame.metadata.begin_frame_ack = ack;
-    view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
+    view_->SubmitCompositorFrame(local_surface_id, std::move(frame));
     view_->RunOnCompositingDidCommit();
     ack.latest_confirmed_sequence_number = 4;
     ack.has_damage = false;
     EXPECT_EQ(ack, source.LastAckForObserver(observer_tracker.last_observer_));
   }
 
   // Change source_id known to the view. This should reset the
   // latest_confirmed_sequence_number tracked by the view.
   source_id = cc::BeginFrameArgs::kManualSourceId;
 
   {
     cc::BeginFrameArgs args = cc::CreateBeginFrameArgsForTesting(
         BEGINFRAME_FROM_HERE, source_id, 10u);
     source.TestOnBeginFrame(args);
 
     // Ack from CompositorFrame is forwarded with invalid
     // latest_confirmed_sequence_number and without damage.
     cc::BeginFrameAck ack(source_id, 10, 10, true);
     gfx::Rect dropped_damage_rect(10, 20, 30, 40);
     cc::CompositorFrame frame =
         MakeDelegatedFrame(1.f, frame_size, dropped_damage_rect);
     frame.metadata.begin_frame_ack = ack;
-    view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
+    view_->SubmitCompositorFrame(local_surface_id, std::move(frame));
     view_->RunOnCompositingDidCommit();
     ack.latest_confirmed_sequence_number =
         cc::BeginFrameArgs::kInvalidFrameNumber;
     ack.has_damage = false;
     EXPECT_EQ(ack, source.LastAckForObserver(observer_tracker.last_observer_));
   }
 
   {
     cc::BeginFrameArgs args = cc::CreateBeginFrameArgsForTesting(
         BEGINFRAME_FROM_HERE, source_id, 11u);
     source.TestOnBeginFrame(args);
 
     // Explicit ack through OnBeginFrameDidNotSwap is forwarded with invalid
     // latest_confirmed_sequence_number.
     cc::BeginFrameAck ack(source_id, 11, 11, false);
     view_->OnBeginFrameDidNotSwap(ack);
     ack.latest_confirmed_sequence_number =
         cc::BeginFrameArgs::kInvalidFrameNumber;
     EXPECT_EQ(ack, source.LastAckForObserver(observer_tracker.last_observer_));
   }
 
   // Unlock the compositor again with a new CompositorFrame of correct size.
   frame_size = view_rect.size();
+  local_surface_id = local_surface_id_allocator_.GenerateId();
 
   {
     cc::BeginFrameArgs args = cc::CreateBeginFrameArgsForTesting(
         BEGINFRAME_FROM_HERE, source_id, 12u);
     source.TestOnBeginFrame(args);
 
     // Ack from CompositorFrame is forwarded.
     cc::BeginFrameAck ack(source_id, 12, 12, true);
     cc::CompositorFrame frame = MakeDelegatedFrame(1.f, frame_size, view_rect);
     frame.metadata.begin_frame_ack = ack;
-    view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
+    view_->SubmitCompositorFrame(local_surface_id, std::move(frame));
     view_->RunOnCompositingDidCommit();
     EXPECT_EQ(ack, source.LastAckForObserver(observer_tracker.last_observer_));
   }
 
   {
     cc::BeginFrameArgs args = cc::CreateBeginFrameArgsForTesting(
         BEGINFRAME_FROM_HERE, source_id, 13u);
     source.TestOnBeginFrame(args);
 
     // Explicit ack through OnBeginFrameDidNotSwap is forwarded.
@@ skipping 2326 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