Hide compositor_frame_sink_id from RenderWidgetHostView*

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 1896 matching lines @@
   cc::ReturnedResource resource;
   resource.id = 1;
   resources.push_back(resource);
   view_->ReclaimResources(resources);
   EXPECT_EQ(1u, sink_->message_count());
   {
     const IPC::Message* msg = sink_->GetMessageAt(0);
     EXPECT_EQ(ViewMsg_ReclaimCompositorResources::ID, msg->type());
     ViewMsg_ReclaimCompositorResources::Param params;
     ViewMsg_ReclaimCompositorResources::Read(msg, &params);
-    EXPECT_EQ(0u, std::get<0>(params));  // compositor_frame_sink_id
     EXPECT_FALSE(std::get<1>(params));   // is_swap_ack
   }
 }
 
 // This test verifies that when the compositor_frame_sink_id changes, the old
 // resources are not returned.
 TEST_F(RenderWidgetHostViewAuraTest, TwoOutputSurfaces) {
   FakeSurfaceObserver manager_observer;
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   cc::SurfaceManager* manager =
       factory->GetContextFactoryPrivate()->GetSurfaceManager();
   manager->AddObserver(&manager_observer);
 
   gfx::Size view_size(100, 100);
   gfx::Rect view_rect(view_size);
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(view_size);
   view_->Show();
   sink_->ClearMessages();
 
   // Submit a frame with resources.
   cc::CompositorFrame frame = MakeDelegatedFrame(1.f, view_size, view_rect);
   cc::TransferableResource resource;
   resource.id = 1;
   frame.resource_list.push_back(resource);
-  view_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId, std::move(frame));
+  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
   EXPECT_EQ(0u, sink_->message_count());
 
-  // Swap another CompositorFrame but this time from another
-  // compositor_frame_sink_id. The resources for the previous frame are old and
-  // should not be returned.
-  view_->OnSwapCompositorFrame(1, CreateLocalSurfaceId(),
+  // Signal that a new RendererCompositorFrameSink was created by the renderer.
+  view_->DidCreateNewRendererCompositorFrameSink();
+
+  // Submit another frame. The resources for the previous frame belong to the
+  // old RendererCompositorFrameSink and should not be returned.
+  view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
                                MakeDelegatedFrame(1.f, view_size, view_rect));
   EXPECT_EQ(0u, sink_->message_count());
 
   // Report that the surface is drawn to trigger an ACK.
   cc::Surface* surface = manager->GetSurfaceForId(view_->surface_id());
   EXPECT_TRUE(surface);
   surface->RunDrawCallbacks();
   EXPECT_EQ(1u, sink_->message_count());
   {
     const IPC::Message* msg = sink_->GetMessageAt(0);
     EXPECT_EQ(ViewMsg_ReclaimCompositorResources::ID, msg->type());
     ViewMsg_ReclaimCompositorResources::Param params;
     ViewMsg_ReclaimCompositorResources::Read(msg, &params);
-    EXPECT_EQ(1u, std::get<0>(params));    // compositor_frame_sink_id
     EXPECT_EQ(true, std::get<1>(params));  // is_swap_ack
   }
 
   manager->RemoveObserver(&manager_observer);
 }
 
 // Resizing in fullscreen mode should send the up-to-date screen info.
 // http://crbug.com/324350
 TEST_F(RenderWidgetHostViewAuraTest, DISABLED_FullscreenResize) {
   aura::Window* root_window = aura_test_helper_->root_window();
@@ skipping 10 matching lines @@
     const IPC::Message* msg = sink_->GetMessageAt(0);
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
     EXPECT_EQ(
         "0,0 800x600",
         std::get<0>(params).screen_info.available_rect.ToString());
     EXPECT_EQ("800x600", std::get<0>(params).new_size.ToString());
     // Resizes are blocked until we swapped a frame of the correct size, and
     // we've committed it.
-    view_->OnSwapCompositorFrame(
-        0, kArbitraryLocalSurfaceId,
+    view_->SubmitCompositorFrame(
+        kArbitraryLocalSurfaceId,
         MakeDelegatedFrame(1.f, std::get<0>(params).new_size,
                            gfx::Rect(std::get<0>(params).new_size)));
     ui::DrawWaiterForTest::WaitForCommit(
         root_window->GetHost()->compositor());
   }
 
   widget_host_->ResetSizeAndRepaintPendingFlags();
   sink_->ClearMessages();
 
   // Make sure the corrent screen size is set along in the resize
   // request when the screen size has changed.
   aura_test_helper_->test_screen()->SetUIScale(0.5);
   EXPECT_EQ(1u, sink_->message_count());
   {
     const IPC::Message* msg = sink_->GetMessageAt(0);
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
     EXPECT_EQ(
         "0,0 1600x1200",
         std::get<0>(params).screen_info.available_rect.ToString());
     EXPECT_EQ("1600x1200", std::get<0>(params).new_size.ToString());
-    view_->OnSwapCompositorFrame(
-        0, kArbitraryLocalSurfaceId,
+    view_->SubmitCompositorFrame(
+        kArbitraryLocalSurfaceId,
         MakeDelegatedFrame(1.f, std::get<0>(params).new_size,
                            gfx::Rect(std::get<0>(params).new_size)));
     ui::DrawWaiterForTest::WaitForCommit(
         root_window->GetHost()->compositor());
   }
 }
 
 // Swapping a frame should notify the window.
 TEST_F(RenderWidgetHostViewAuraTest, SwapNotifiesWindow) {
   gfx::Size view_size(100, 100);
   gfx::Rect view_rect(view_size);
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(view_size);
   view_->Show();
 
   MockWindowObserver observer;
   view_->window_->AddObserver(&observer);
 
   // Delegated renderer path
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId,
                                MakeDelegatedFrame(1.f, view_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
 
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_,
                                                gfx::Rect(5, 5, 5, 5)));
-  view_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, view_size, gfx::Rect(5, 5, 5, 5)));
   testing::Mock::VerifyAndClearExpectations(&observer);
 
   view_->window_->RemoveObserver(&observer);
 }
 
 // Mirroring the layers for a window should cause Surface destruction to
 // depend on both layers.
 TEST_F(RenderWidgetHostViewAuraTest, MirrorLayers) {
   gfx::Size view_size(100, 100);
   gfx::Rect view_rect(view_size);
   aura::Window* const root = parent_view_->GetNativeView()->GetRootWindow();
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), root, gfx::Rect());
   view_->SetSize(view_size);
   view_->Show();
 
-  view_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId,
                                MakeDelegatedFrame(1.f, view_size, view_rect));
   std::unique_ptr<ui::LayerTreeOwner> mirror(wm::MirrorLayers(
       view_->GetNativeView(), false /* sync_bounds */));
 
   cc::SurfaceId id = view_->GetDelegatedFrameHost()->SurfaceIdForTesting();
   if (id.is_valid()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     cc::SurfaceManager* manager =
         factory->GetContextFactoryPrivate()->GetSurfaceManager();
     cc::Surface* surface = manager->GetSurfaceForId(id);
@@ skipping 22 matching lines @@
 
   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_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId, std::move(frame));
+  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, 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_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId, std::move(frame));
+  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, 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);
 
   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_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       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).
@@ skipping 17 matching lines @@
   sink_->ClearMessages();
 
   // 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_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, size3, gfx::Rect(size3)));
   // Expect the frame ack;
   EXPECT_EQ(1u, sink_->message_count());
   EXPECT_EQ(ViewMsg_ReclaimCompositorResources::ID,
             sink_->GetMessageAt(0)->type());
   sink_->ClearMessages();
   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_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, size2, gfx::Rect(size2)));
   cc::SurfaceId surface_id = view_->surface_id();
   if (!surface_id.is_valid()) {
     // No frame ack yet.
     EXPECT_EQ(0u, sink_->message_count());
   } else {
     // Frame isn't desired size, so early ack.
     EXPECT_EQ(1u, sink_->message_count());
   }
   EXPECT_EQ(size2.ToString(), view_->GetRequestedRendererSize().ToString());
@@ skipping 51 matching lines @@
       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_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId,
                                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_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, partial_view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // Lock the compositor. Now we should drop frames.
   view_rect = gfx::Rect(150, 150);
   view_->SetSize(view_rect.size());
 
   // This frame is dropped.
   gfx::Rect dropped_damage_rect_1(10, 20, 30, 40);
   EXPECT_CALL(observer, OnDelegatedFrameDamage(_, _)).Times(0);
-  view_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       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_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, dropped_damage_rect_2));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // Unlock the compositor. This frame should damage everything.
   frame_size = view_rect.size();
 
   gfx::Rect new_damage_rect(5, 6, 10, 10);
   EXPECT_CALL(observer,
               OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, new_damage_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // A partial damage frame, this should not be dropped.
   EXPECT_CALL(observer,
               OnDelegatedFrameDamage(view_->window_, partial_view_rect));
-  view_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, frame_size, partial_view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
 
   // Resize to something empty.
   view_rect = gfx::Rect(100, 0);
   view_->SetSize(view_rect.size());
 
   // We're never expecting empty frames, resize to something non-empty.
   view_rect = gfx::Rect(100, 100);
   view_->SetSize(view_rect.size());
 
   // This frame should not be dropped.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->OnSwapCompositorFrame(
-      0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, view_rect.size(), view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   view_->window_->RemoveObserver(&observer);
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, OutputSurfaceIdChange) {
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
 
   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);
 
   // Swap a frame.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId,
+  view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId,
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
-  // Swap a frame with a different surface id.
+  // Signal that a new RendererCompositorFrameSink was created.
+  view_->DidCreateNewRendererCompositorFrameSink();
+
+  // Submit a frame from the new RendererCompositorFrameSink.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->OnSwapCompositorFrame(1, CreateLocalSurfaceId(),
+  view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
-  // Swap an empty frame, with a different surface id.
-  view_->OnSwapCompositorFrame(
-      2, CreateLocalSurfaceId(),
+  // Signal that a new RendererCompositorFrameSink was created.
+  view_->DidCreateNewRendererCompositorFrameSink();
+
+  // Submit a frame from the new RendererCompositorFrameSink.
+  view_->SubmitCompositorFrame(
+      CreateLocalSurfaceId(),
       MakeDelegatedFrame(1.f, gfx::Size(), gfx::Rect()));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
+  // Signal that a new RendererCompositorFrameSink was created.
+  view_->DidCreateNewRendererCompositorFrameSink();
+
   // Swap another frame, with a different surface id.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
-  view_->OnSwapCompositorFrame(3, CreateLocalSurfaceId(),
+  view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
                                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 23 matching lines @@
     aura::client::ParentWindowWithContext(
         views[i]->GetNativeView(),
         parent_view_->GetNativeView()->GetRootWindow(),
         gfx::Rect());
     views[i]->SetSize(view_rect.size());
   }
 
   // Make each renderer visible, and swap a frame on it, then make it invisible.
   for (size_t i = 0; i < renderer_count; ++i) {
     views[i]->Show();
-    views[i]->OnSwapCompositorFrame(
-        1, kArbitraryLocalSurfaceId,
+    views[i]->SubmitCompositorFrame(
+        kArbitraryLocalSurfaceId,
         MakeDelegatedFrame(1.f, frame_size, view_rect));
     EXPECT_TRUE(views[i]->HasFrameData());
     views[i]->Hide();
   }
 
   // There should be max_renderer_frames with a frame in it, and one without it.
   // Since the logic is LRU eviction, the first one should be without.
   EXPECT_FALSE(views[0]->HasFrameData());
   for (size_t i = 1; i < renderer_count; ++i)
     EXPECT_TRUE(views[i]->HasFrameData());
 
   // LRU renderer is [0], make it visible, it shouldn't evict anything yet.
   views[0]->Show();
   EXPECT_FALSE(views[0]->HasFrameData());
   EXPECT_TRUE(views[1]->HasFrameData());
   // Since [0] doesn't have a frame, it should be waiting for the renderer to
   // give it one.
   EXPECT_TRUE(views[0]->released_front_lock_active());
 
   // Swap a frame on it, it should evict the next LRU [1].
-  views[0]->OnSwapCompositorFrame(
-      1, kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, frame_size, view_rect));
+  views[0]->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId, MakeDelegatedFrame(1.f, frame_size, view_rect));
   EXPECT_TRUE(views[0]->HasFrameData());
   EXPECT_FALSE(views[1]->HasFrameData());
   // Now that [0] got a frame, it shouldn't be waiting any more.
   EXPECT_FALSE(views[0]->released_front_lock_active());
   views[0]->Hide();
 
   // LRU renderer is [1], still hidden. Swap a frame on it, it should evict
   // the next LRU [2].
-  views[1]->OnSwapCompositorFrame(
-      1, kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, frame_size, view_rect));
+  views[1]->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId, MakeDelegatedFrame(1.f, frame_size, view_rect));
   EXPECT_TRUE(views[0]->HasFrameData());
   EXPECT_TRUE(views[1]->HasFrameData());
   EXPECT_FALSE(views[2]->HasFrameData());
   for (size_t i = 3; i < renderer_count; ++i)
     EXPECT_TRUE(views[i]->HasFrameData());
 
   // Make all renderers but [0] visible and swap a frame on them, keep [0]
   // hidden, it becomes the LRU.
   for (size_t i = 1; i < renderer_count; ++i) {
     views[i]->Show();
     // The renderers who don't have a frame should be waiting. The ones that
     // have a frame should not.
     // In practice, [1] has a frame, but anything after has its frame evicted.
     EXPECT_EQ(!views[i]->HasFrameData(),
               views[i]->released_front_lock_active());
-    views[i]->OnSwapCompositorFrame(
-        1, kArbitraryLocalSurfaceId,
+    views[i]->SubmitCompositorFrame(
+        kArbitraryLocalSurfaceId,
         MakeDelegatedFrame(1.f, frame_size, view_rect));
     // Now everyone has a frame.
     EXPECT_FALSE(views[i]->released_front_lock_active());
     EXPECT_TRUE(views[i]->HasFrameData());
   }
   EXPECT_FALSE(views[0]->HasFrameData());
 
   // Swap a frame on [0], it should be evicted immediately.
-  views[0]->OnSwapCompositorFrame(
-      1, kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, frame_size, view_rect));
+  views[0]->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId, MakeDelegatedFrame(1.f, frame_size, view_rect));
   EXPECT_FALSE(views[0]->HasFrameData());
 
   // Make [0] visible, and swap a frame on it. Nothing should be evicted
   // although we're above the limit.
   views[0]->Show();
   // We don't have a frame, wait.
   EXPECT_TRUE(views[0]->released_front_lock_active());
-  views[0]->OnSwapCompositorFrame(
-      1, kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, frame_size, view_rect));
+  views[0]->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId, MakeDelegatedFrame(1.f, frame_size, view_rect));
   EXPECT_FALSE(views[0]->released_front_lock_active());
   for (size_t i = 0; i < renderer_count; ++i)
     EXPECT_TRUE(views[i]->HasFrameData());
 
   // Make [0] hidden, it should evict its frame.
   views[0]->Hide();
   EXPECT_FALSE(views[0]->HasFrameData());
 
   // Make [0] visible, don't give it a frame, it should be waiting.
   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);
   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]->OnSwapCompositorFrame(
-      1, kArbitraryLocalSurfaceId,
+  views[1]->SubmitCompositorFrame(
+      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);
@@ skipping 53 matching lines @@
         views[i]->GetNativeView(),
         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]->OnSwapCompositorFrame(
-        1, i ? CreateLocalSurfaceId() : kArbitraryLocalSurfaceId,
+    views[i]->SubmitCompositorFrame(
+        i ? CreateLocalSurfaceId() : 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();
-  views[0]->OnSwapCompositorFrame(
-      1, kArbitraryLocalSurfaceId,
-      MakeDelegatedFrame(1.f, frame_size, view_rect));
+  views[0]->SubmitCompositorFrame(
+      kArbitraryLocalSurfaceId, MakeDelegatedFrame(1.f, frame_size, view_rect));
   EXPECT_TRUE(views[0]->HasFrameData());
   views[0]->GetDelegatedFrameHost()->LockResources();
   views[0]->Hide();
   EXPECT_TRUE(views[0]->HasFrameData());
 
   // If we unlock [0] now, then [0] should be evicted.
   views[0]->GetDelegatedFrameHost()->UnlockResources();
   EXPECT_FALSE(views[0]->HasFrameData());
 
   for (size_t i = 0; i < renderer_count; ++i) {
@@ skipping 38 matching lines @@
         views[i]->GetNativeView(),
         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]->OnSwapCompositorFrame(
-        1, kArbitraryLocalSurfaceId,
+    views[i]->SubmitCompositorFrame(
+        kArbitraryLocalSurfaceId,
         MakeDelegatedFrame(1.f, frame_size, view_rect));
     EXPECT_TRUE(views[i]->HasFrameData());
   }
 
   // If we hide one, it should not get evicted.
   views[0]->Hide();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(views[0]->HasFrameData());
   // Using a lesser memory pressure event however, should evict.
   SimulateMemoryPressure(
@@ skipping 85 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_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId, std::move(frame));
+    view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, 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_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId, std::move(frame));
+    view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, 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_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId, std::move(frame));
+    view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, 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);
@@ skipping 13 matching lines @@
 
   {
     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_->OnSwapCompositorFrame(0, kArbitraryLocalSurfaceId, std::move(frame));
+    view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, 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 49 matching lines @@
     ASSERT_EQ(0, callback_count_);
     ASSERT_FALSE(view_->last_copy_request_);
   }
 
   void InstallFakeTickClock() {
     // Create a fake tick clock and transfer ownership to the frame host.
     tick_clock_ = new base::SimpleTestTickClock();
     view_->GetDelegatedFrameHost()->tick_clock_ = base::WrapUnique(tick_clock_);
   }
 
-  void OnSwapCompositorFrame() {
-    view_->OnSwapCompositorFrame(
-        1, kArbitraryLocalSurfaceId,
+  void SubmitCompositorFrame() {
+    view_->SubmitCompositorFrame(
+        kArbitraryLocalSurfaceId,
         MakeDelegatedFrame(1.f, view_rect_.size(), view_rect_));
     cc::SurfaceId surface_id =
         view_->GetDelegatedFrameHost()->SurfaceIdForTesting();
     if (surface_id.is_valid())
       view_->GetDelegatedFrameHost()->WillDrawSurface(
           surface_id.local_surface_id(), view_rect_);
     ASSERT_TRUE(view_->last_copy_request_);
   }
 
   void ReleaseSwappedFrame() {
     std::unique_ptr<cc::CopyOutputRequest> request =
         std::move(view_->last_copy_request_);
     request->SendTextureResult(view_rect_.size(), request->texture_mailbox(),
                                std::unique_ptr<cc::SingleReleaseCallback>());
     RunLoopUntilCallback();
   }
 
-  void OnSwapCompositorFrameAndRelease() {
-    OnSwapCompositorFrame();
+  void SubmitCompositorFrameAndRelease() {
+    SubmitCompositorFrame();
     ReleaseSwappedFrame();
   }
 
   void RunOnCompositingDidCommitAndReleaseFrame() {
     view_->RunOnCompositingDidCommit();
     ReleaseSwappedFrame();
   }
 
   void OnUpdateVSyncParameters(base::TimeTicks timebase,
                                base::TimeDelta interval) {
@@ skipping 25 matching lines @@
 // browser composites, and even if the frame subscriber desires more frames than
 // the number of browser composites.
 TEST_F(RenderWidgetHostViewAuraCopyRequestTest, DedupeFrameSubscriberRequests) {
   InitializeView();
   int expected_callback_count = 0;
 
   // Normal case: A browser composite executes for each render frame swap.
   for (int i = 0; i < 3; ++i) {
     // Renderer provides another frame and the Browser composites with the
     // frame, executing the copy request, and then the result is delivered.
-    OnSwapCompositorFrame();
+    SubmitCompositorFrame();
     RunOnCompositingDidCommitAndReleaseFrame();
 
     // The callback should be run with success status.
     ++expected_callback_count;
     ASSERT_EQ(expected_callback_count, callback_count_);
     EXPECT_TRUE(result_);
   }
 
   // De-duping case: One browser composite executes per varied number of render
   // frame swaps.
   for (int i = 0; i < 3; ++i) {
     const int num_swaps = 1 + i % 3;
 
     // The renderer provides |num_swaps| frames.
     for (int j = 0; j < num_swaps; ++j) {
-      OnSwapCompositorFrame();
+      SubmitCompositorFrame();
       if (j > 0) {
         ++expected_callback_count;
         ASSERT_EQ(expected_callback_count, callback_count_);
         EXPECT_FALSE(result_);  // The prior copy request was aborted.
       }
     }
 
     // Browser composites with the frame, executing the last copy request that
     // was made, and then the result is delivered.
     RunOnCompositingDidCommitAndReleaseFrame();
 
     // The final callback should be run with success status.
     ++expected_callback_count;
     ASSERT_EQ(expected_callback_count, callback_count_);
     EXPECT_TRUE(result_);
   }
 
   // Destroy the RenderWidgetHostViewAura and ImageTransportFactory.
   TearDownEnvironment();
 }
 
 TEST_F(RenderWidgetHostViewAuraCopyRequestTest, DestroyedAfterCopyRequest) {
   InitializeView();
 
-  OnSwapCompositorFrame();
+  SubmitCompositorFrame();
   EXPECT_EQ(0, callback_count_);
   EXPECT_TRUE(view_->last_copy_request_);
   EXPECT_TRUE(view_->last_copy_request_->has_texture_mailbox());
 
   // Notify DelegatedFrameHost that the copy requests were moved to the
   // compositor thread by calling OnCompositingDidCommit().
   //
   // Send back the mailbox included in the request. There's no release callback
   // since the mailbox came from the RWHVA originally.
   RunOnCompositingDidCommitAndReleaseFrame();
 
   // The callback should succeed.
   EXPECT_EQ(1, callback_count_);
   EXPECT_TRUE(result_);
 
-  OnSwapCompositorFrame();
+  SubmitCompositorFrame();
   EXPECT_EQ(1, callback_count_);
   std::unique_ptr<cc::CopyOutputRequest> request =
       std::move(view_->last_copy_request_);
 
   // Destroy the RenderWidgetHostViewAura and ImageTransportFactory.
   TearDownEnvironment();
 
   // Send the result after-the-fact.  It goes nowhere since DelegatedFrameHost
   // has been destroyed.
   request->SendTextureResult(view_rect_.size(), request->texture_mailbox(),
@@ skipping 20 matching lines @@
   const base::TimeDelta kDefaultInterval =
       cc::BeginFrameArgs::DefaultInterval();
   tick_clock_->Advance(kDefaultInterval / 3);
 
   // Swap the first frame without any vsync information.
   ASSERT_EQ(base::TimeTicks(), vsync_timebase());
   ASSERT_EQ(base::TimeDelta(), vsync_interval());
 
   // During this first call, there is no known vsync information, so while the
   // callback should succeed the present time is effectively just current time.
-  OnSwapCompositorFrameAndRelease();
+  SubmitCompositorFrameAndRelease();
   EXPECT_EQ(tick_clock_->NowTicks(), frame_subscriber_->last_present_time());
 
   // Now initialize the vsync parameters with a null timebase, but a known vsync
   // interval; which should give us slightly better frame time estimates.
   OnUpdateVSyncParameters(base::TimeTicks(), kDefaultInterval);
   ASSERT_EQ(base::TimeTicks(), vsync_timebase());
   ASSERT_EQ(kDefaultInterval, vsync_interval());
 
   // Now that we have a vsync interval, the presentation time estimate should be
   // the nearest presentation interval, which is just kDefaultInterval since our
   // tick clock is initialized to a time before that.
-  OnSwapCompositorFrameAndRelease();
+  SubmitCompositorFrameAndRelease();
   EXPECT_EQ(base::TimeTicks() + kDefaultInterval,
             frame_subscriber_->last_present_time());
 
   // Now initialize the vsync parameters with a valid timebase and a known vsync
   // interval; which should give us the best frame time estimates.
   const base::TimeTicks kBaseTime = tick_clock_->NowTicks();
   OnUpdateVSyncParameters(kBaseTime, kDefaultInterval);
   ASSERT_EQ(kBaseTime, vsync_timebase());
   ASSERT_EQ(kDefaultInterval, vsync_interval());
 
   // Now that we have a vsync interval and a timebase, the presentation time
   // should be based on the number of vsync intervals which have elapsed since
   // the vsync timebase.  Advance time by a non integer number of intervals to
   // verify.
   const double kElapsedIntervals = 2.5;
   tick_clock_->Advance(kDefaultInterval * kElapsedIntervals);
-  OnSwapCompositorFrameAndRelease();
+  SubmitCompositorFrameAndRelease();
   EXPECT_EQ(kBaseTime + kDefaultInterval * std::ceil(kElapsedIntervals),
             frame_subscriber_->last_present_time());
 
   // Destroy the RenderWidgetHostViewAura and ImageTransportFactory.
   TearDownEnvironment();
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, VisibleViewportTest) {
   gfx::Rect view_rect(100, 100);
 
@@ skipping 1867 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