cc: Dedup IPCs to return resources to client

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 198 matching lines @@
     if (window_)
       window_->RemoveObserver(this);
   }
 
   bool destroyed() const { return destroyed_; }
 
   // aura::WindowObserver overrides:
   void OnWindowDestroyed(aura::Window* window) override {
     CHECK_EQ(window, window_);
     destroyed_ = true;
-    window_ = NULL;
+    window_ = nullptr;
   }
 
  private:
-  // Window that we're observing, or NULL if it's been destroyed.
+  // Window that we're observing, or nullptr if it's been destroyed.
   aura::Window* window_;
 
   // Was |window_| destroyed?
   bool destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowObserver);
 };
 
+class FakeSurfaceDamageObserver : public cc::SurfaceDamageObserver {
+ public:
+  void OnSurfaceDamaged(const cc::SurfaceId& id, bool* changed) override {
+    *changed = true;
+  }
+};
+
 class FakeFrameSubscriber : public RenderWidgetHostViewFrameSubscriber {
  public:
   FakeFrameSubscriber(gfx::Size size, base::Callback<void(bool)> callback)
       : size_(size), callback_(callback), should_capture_(true) {}
 
   bool ShouldCaptureFrame(const gfx::Rect& damage_rect,
                           base::TimeTicks present_time,
                           scoped_refptr<media::VideoFrame>* storage,
                           DeliverFrameCallback* callback) override {
     if (!should_capture_)
@@ skipping 99 matching lines @@
   }
 
   bool HasFrameData() const {
     return !surface_id().is_null();
   }
 
   bool released_front_lock_active() const {
     return GetDelegatedFrameHost()->ReleasedFrontLockActiveForTesting();
   }
 
+  void ReturnResources(const cc::ReturnedResourceArray& resources) {
+    GetDelegatedFrameHost()->ReturnResources(resources);
+  }
+
+  void ResetCompositor() { GetDelegatedFrameHost()->ResetCompositor(); }
+
   // A lock that doesn't actually do anything to the compositor, and does not
   // time out.
   class FakeResizeLock : public ResizeLock {
    public:
     FakeResizeLock(const gfx::Size new_size, bool defer_compositor_lock)
         : ResizeLock(new_size, defer_compositor_lock) {}
   };
 
   const ui::MotionEventAura& pointer_state_for_test() {
     return pointer_state();
@@ skipping 38 matching lines @@
 class MockWindowObserver : public aura::WindowObserver {
  public:
   MOCK_METHOD2(OnDelegatedFrameDamage, void(aura::Window*, const gfx::Rect&));
 };
 
 const WebInputEvent* GetInputEventFromMessage(const IPC::Message& message) {
   base::PickleIterator iter(message);
   const char* data;
   int data_length;
   if (!iter.ReadData(&data, &data_length))
-    return NULL;
+    return nullptr;
   return reinterpret_cast<const WebInputEvent*>(data);
 }
 
 }  // namespace
 
 class RenderWidgetHostViewAuraTest : public testing::Test {
  public:
   RenderWidgetHostViewAuraTest()
       : widget_host_uses_shutdown_to_destroy_(false),
         is_guest_view_hack_(false),
@@ skipping 14 matching lines @@
 
     sink_ = &process_host_->sink();
 
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     parent_host_ = new RenderWidgetHostImpl(delegates_.back().get(),
                                             process_host_, routing_id, false);
     delegates_.back()->set_widget_host(parent_host_);
     parent_view_ = new RenderWidgetHostViewAura(parent_host_,
                                                 is_guest_view_hack_);
-    parent_view_->InitAsChild(NULL);
+    parent_view_->InitAsChild(nullptr);
     aura::client::ParentWindowWithContext(parent_view_->GetNativeView(),
                                           aura_test_helper_->root_window(),
                                           gfx::Rect());
 
     routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     widget_host_ = new RenderWidgetHostImpl(delegates_.back().get(),
                                             process_host_, routing_id, false);
     delegates_.back()->set_widget_host(widget_host_);
     widget_host_->Init();
     view_ = new FakeRenderWidgetHostViewAura(widget_host_, is_guest_view_hack_);
   }
 
   void TearDownEnvironment() {
-    sink_ = NULL;
-    process_host_ = NULL;
+    sink_ = nullptr;
+    process_host_ = nullptr;
     if (view_) {
       // For guest-views, |view_| is not the view used by |widget_host_|.
       if (!is_guest_view_hack_) {
         EXPECT_EQ(view_, widget_host_->GetView());
       }
       view_->Destroy();
       if (!is_guest_view_hack_) {
         EXPECT_EQ(nullptr, widget_host_->GetView());
       }
     }
@@ skipping 111 matching lines @@
 
   bool is_guest_view_hack_;
 
   base::MessageLoopForUI message_loop_;
   BrowserThreadImpl browser_thread_for_ui_;
   std::unique_ptr<aura::test::AuraTestHelper> aura_test_helper_;
   std::unique_ptr<BrowserContext> browser_context_;
   std::vector<std::unique_ptr<MockRenderWidgetHostDelegate>> delegates_;
   MockRenderProcessHost* process_host_;
 
-  // Tests should set these to NULL if they've already triggered their
+  // Tests should set these to nullptr if they've already triggered their
   // destruction.
   RenderWidgetHostImpl* parent_host_;
   RenderWidgetHostViewAura* parent_view_;
 
-  // Tests should set these to NULL if they've already triggered their
+  // Tests should set these to nullptr if they've already triggered their
   // destruction.
   RenderWidgetHostImpl* widget_host_;
   FakeRenderWidgetHostViewAura* view_;
 
   IPC::TestSink* sink_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraTest);
 };
 
 // Helper class to instantiate RenderWidgetHostViewGuest which is backed
 // by an aura platform view.
 class RenderWidgetHostViewGuestAuraTest : public RenderWidgetHostViewAuraTest {
  public:
   RenderWidgetHostViewGuestAuraTest() {
     // Use RWH::Shutdown to destroy RWH, instead of deleting.
     // This will ensure that the RenderWidgetHostViewGuest is not leaked and
     // is deleted properly upon RWH going away.
     set_widget_host_uses_shutdown_to_destroy(true);
   }
 
   // We explicitly invoke SetUp to allow gesture debounce customization.
   void SetUp() override {
     is_guest_view_hack_ = true;
 
     RenderWidgetHostViewAuraTest::SetUp();
 
-    guest_view_weak_ = (new RenderWidgetHostViewGuest(
-        widget_host_, NULL, view_->GetWeakPtr()))->GetWeakPtr();
+    guest_view_weak_ = (new RenderWidgetHostViewGuest(widget_host_, nullptr,
+                                                      view_->GetWeakPtr()))
+                           ->GetWeakPtr();
   }
 
   void TearDown() override {
     // Internal override to do nothing, we clean up ourselves in the test body.
     // This helps us test that |guest_view_weak_| does not leak.
   }
 
  protected:
   base::WeakPtr<RenderWidgetHostViewBase> guest_view_weak_;
 
@@ skipping 20 matching lines @@
   void SetUpOverscrollEnvironmentImpl(int debounce_interval_in_ms) {
     ui::GestureConfiguration::GetInstance()->set_scroll_debounce_interval_in_ms(
         debounce_interval_in_ms);
 
     RenderWidgetHostViewAuraTest::SetUp();
 
     view_->SetOverscrollControllerEnabled(true);
     overscroll_delegate_.reset(new TestOverscrollDelegate(view_));
     view_->overscroll_controller()->set_delegate(overscroll_delegate_.get());
 
-    view_->InitAsChild(NULL);
+    view_->InitAsChild(nullptr);
     view_->SetBounds(gfx::Rect(0, 0, 400, 200));
     view_->Show();
 
     sink_->ClearMessages();
   }
 
   // TODO(jdduke): Simulate ui::Events, injecting through the view.
   void SimulateMouseEvent(WebInputEvent::Type type) {
     widget_host_->ForwardMouseEvent(SyntheticWebMouseEventBuilder::Build(type));
   }
@@ skipping 168 matching lines @@
 // initialized.
 TEST_F(RenderWidgetHostViewAuraTest, DestructionBeforeProperInitialization) {
   // Terminate the test without initializing |view_|.
 }
 
 // Checks that a fullscreen view has the correct show-state and receives the
 // focus.
 TEST_F(RenderWidgetHostViewAuraTest, FocusFullscreen) {
   view_->InitAsFullscreen(parent_view_);
   aura::Window* window = view_->GetNativeView();
-  ASSERT_TRUE(window != NULL);
+  ASSERT_TRUE(window != nullptr);
   EXPECT_EQ(ui::SHOW_STATE_FULLSCREEN,
             window->GetProperty(aura::client::kShowStateKey));
 
   // Check that we requested and received the focus.
   EXPECT_TRUE(window->HasFocus());
 
   // Check that we'll also say it's okay to activate the window when there's an
   // ActivationClient defined.
   EXPECT_TRUE(view_->ShouldActivate());
 }
@@ skipping 26 matching lines @@
   view_->SetBounds(bounds_in_screen);
   final_bounds_in_screen = view_->GetViewBounds();
   EXPECT_EQ(final_bounds_in_screen.ToString(), bounds_in_screen.ToString());
 
   // Verify that setting the size does not alter the origin.
   gfx::Point original_origin = window->bounds().origin();
   view_->SetSize(gfx::Size(120, 120));
   gfx::Point new_origin = window->bounds().origin();
   EXPECT_EQ(original_origin.ToString(), new_origin.ToString());
 
-  aura::client::SetScreenPositionClient(root, NULL);
+  aura::client::SetScreenPositionClient(root, nullptr);
 }
 
 // Checks that moving parent sends new screen bounds.
 TEST_F(RenderWidgetHostViewAuraTest, ParentMovementUpdatesScreenRect) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
 
   aura::Window* root = parent_view_->GetNativeView()->GetRootWindow();
 
   aura::test::TestWindowDelegate delegate1, delegate2;
   std::unique_ptr<aura::Window> parent1(new aura::Window(&delegate1));
   parent1->Init(ui::LAYER_TEXTURED);
   parent1->Show();
   std::unique_ptr<aura::Window> parent2(new aura::Window(&delegate2));
   parent2->Init(ui::LAYER_TEXTURED);
   parent2->Show();
 
   root->AddChild(parent1.get());
   parent1->AddChild(parent2.get());
   parent2->AddChild(view_->GetNativeView());
 
   root->SetBounds(gfx::Rect(0, 0, 800, 600));
   parent1->SetBounds(gfx::Rect(1, 1, 300, 300));
   parent2->SetBounds(gfx::Rect(2, 2, 200, 200));
   view_->SetBounds(gfx::Rect(3, 3, 100, 100));
   // view_ will be destroyed when parent is destroyed.
-  view_ = NULL;
+  view_ = nullptr;
 
   // Flush the state after initial setup is done.
   widget_host_->OnMessageReceived(
       ViewHostMsg_UpdateScreenRects_ACK(widget_host_->GetRoutingID()));
   widget_host_->OnMessageReceived(
       ViewHostMsg_UpdateScreenRects_ACK(widget_host_->GetRoutingID()));
   sink_->ClearMessages();
 
   // Move parents.
   parent2->SetBounds(gfx::Rect(20, 20, 200, 200));
@@ skipping 21 matching lines @@
   widget_host_->OnMessageReceived(
       ViewHostMsg_UpdateScreenRects_ACK(widget_host_->GetRoutingID()));
   // There should not be any pending update.
   EXPECT_EQ(0U, sink_->message_count());
 }
 
 // Checks that a fullscreen view is destroyed when it loses the focus.
 TEST_F(RenderWidgetHostViewAuraTest, DestroyFullscreenOnBlur) {
   view_->InitAsFullscreen(parent_view_);
   aura::Window* window = view_->GetNativeView();
-  ASSERT_TRUE(window != NULL);
+  ASSERT_TRUE(window != nullptr);
   ASSERT_TRUE(window->HasFocus());
 
   // After we create and focus another window, the RWHVA's window should be
   // destroyed.
   TestWindowObserver observer(window);
   aura::test::TestWindowDelegate delegate;
   std::unique_ptr<aura::Window> sibling(new aura::Window(&delegate));
   sibling->Init(ui::LAYER_TEXTURED);
   sibling->Show();
   window->parent()->AddChild(sibling.get());
   sibling->Focus();
   ASSERT_TRUE(sibling->HasFocus());
   ASSERT_TRUE(observer.destroyed());
 
-  widget_host_ = NULL;
-  view_ = NULL;
+  widget_host_ = nullptr;
+  view_ = nullptr;
 }
 
 // Checks that a popup view is destroyed when a user clicks outside of the popup
 // view and focus does not change. This is the case when the user clicks on the
 // desktop background on Chrome OS.
 TEST_F(RenderWidgetHostViewAuraTest, DestroyPopupClickOutsidePopup) {
   parent_view_->SetBounds(gfx::Rect(10, 10, 400, 400));
   parent_view_->Focus();
   EXPECT_TRUE(parent_view_->HasFocus());
 
   view_->InitAsPopup(parent_view_, gfx::Rect(10, 10, 100, 100));
   aura::Window* window = view_->GetNativeView();
-  ASSERT_TRUE(window != NULL);
+  ASSERT_TRUE(window != nullptr);
 
   gfx::Point click_point;
   EXPECT_FALSE(window->GetBoundsInRootWindow().Contains(click_point));
   aura::Window* parent_window = parent_view_->GetNativeView();
   EXPECT_FALSE(parent_window->GetBoundsInRootWindow().Contains(click_point));
 
   TestWindowObserver observer(window);
   ui::test::EventGenerator generator(window->GetRootWindow(), click_point);
   generator.ClickLeftButton();
   ASSERT_TRUE(parent_view_->HasFocus());
   ASSERT_TRUE(observer.destroyed());
 
-  widget_host_ = NULL;
-  view_ = NULL;
+  widget_host_ = nullptr;
+  view_ = nullptr;
 }
 
 // Checks that a popup view is destroyed when a user taps outside of the popup
 // view and focus does not change. This is the case when the user taps the
 // desktop background on Chrome OS.
 TEST_F(RenderWidgetHostViewAuraTest, DestroyPopupTapOutsidePopup) {
   parent_view_->SetBounds(gfx::Rect(10, 10, 400, 400));
   parent_view_->Focus();
   EXPECT_TRUE(parent_view_->HasFocus());
 
   view_->InitAsPopup(parent_view_, gfx::Rect(10, 10, 100, 100));
   aura::Window* window = view_->GetNativeView();
-  ASSERT_TRUE(window != NULL);
+  ASSERT_TRUE(window != nullptr);
 
   gfx::Point tap_point;
   EXPECT_FALSE(window->GetBoundsInRootWindow().Contains(tap_point));
   aura::Window* parent_window = parent_view_->GetNativeView();
   EXPECT_FALSE(parent_window->GetBoundsInRootWindow().Contains(tap_point));
 
   TestWindowObserver observer(window);
   ui::test::EventGenerator generator(window->GetRootWindow(), tap_point);
   generator.GestureTapAt(tap_point);
   ASSERT_TRUE(parent_view_->HasFocus());
   ASSERT_TRUE(observer.destroyed());
 
-  widget_host_ = NULL;
-  view_ = NULL;
+  widget_host_ = nullptr;
+  view_ = nullptr;
 }
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 
 // On Desktop Linux, select boxes need mouse capture in order to work. Test that
 // when a select box is opened via a mouse press that it retains mouse capture
 // after the mouse is released.
 TEST_F(RenderWidgetHostViewAuraTest, PopupRetainsCaptureAfterMouseRelease) {
   parent_view_->SetBounds(gfx::Rect(10, 10, 400, 400));
   parent_view_->Focus();
@@ skipping 32 matching lines @@
   dialog_window->Init(ui::LAYER_TEXTURED);
   aura::client::ParentWindowWithContext(
       dialog_window.get(), popup_window, gfx::Rect());
   dialog_window->Show();
   wm::ActivateWindow(dialog_window.get());
   dialog_window->Focus();
 
   ASSERT_TRUE(wm::IsActiveWindow(dialog_window.get()));
   EXPECT_TRUE(observer.destroyed());
 
-  widget_host_ = NULL;
-  view_ = NULL;
+  widget_host_ = nullptr;
+  view_ = nullptr;
 }
 
 // Checks that IME-composition-event state is maintained correctly.
 TEST_F(RenderWidgetHostViewAuraTest, SetCompositionText) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
   ActivateViewForTextInputManager(view_, ui::TEXT_INPUT_TYPE_TEXT);
 
   ui::CompositionText composition_text;
   composition_text.text = base::ASCIIToUTF16("|a|b");
 
   // Focused segment
   composition_text.underlines.push_back(
       ui::CompositionUnderline(0, 3, 0xff000000, true, 0x78563412));
 
   // Non-focused segment, with different background color.
   composition_text.underlines.push_back(
       ui::CompositionUnderline(3, 4, 0xff000000, false, 0xefcdab90));
 
   const ui::CompositionUnderlines& underlines = composition_text.underlines;
 
   // Caret is at the end. (This emulates Japanese MSIME 2007 and later)
   composition_text.selection = gfx::Range(4);
 
   sink_->ClearMessages();
   view_->SetCompositionText(composition_text);
   EXPECT_TRUE(view_->has_composition_text_);
   {
     const IPC::Message* msg =
       sink_->GetFirstMessageMatching(InputMsg_ImeSetComposition::ID);
-    ASSERT_TRUE(msg != NULL);
+    ASSERT_TRUE(msg != nullptr);
 
     InputMsg_ImeSetComposition::Param params;
     InputMsg_ImeSetComposition::Read(msg, &params);
     // composition text
     EXPECT_EQ(composition_text.text, std::get<0>(params));
     // underlines
     ASSERT_EQ(underlines.size(), std::get<1>(params).size());
     for (size_t i = 0; i < underlines.size(); ++i) {
       EXPECT_EQ(underlines[i].start_offset, std::get<1>(params)[i].startOffset);
       EXPECT_EQ(underlines[i].end_offset, std::get<1>(params)[i].endOffset);
       EXPECT_EQ(underlines[i].color, std::get<1>(params)[i].color);
       EXPECT_EQ(underlines[i].thick, std::get<1>(params)[i].thick);
       EXPECT_EQ(underlines[i].background_color,
                 std::get<1>(params)[i].backgroundColor);
     }
     EXPECT_EQ(gfx::Range::InvalidRange(), std::get<2>(params));
     // highlighted range
     EXPECT_EQ(4, std::get<3>(params)) << "Should be the same to the caret pos";
     EXPECT_EQ(4, std::get<4>(params)) << "Should be the same to the caret pos";
   }
 
   view_->ImeCancelComposition();
   EXPECT_FALSE(view_->has_composition_text_);
 }
 
 // Checks that sequence of IME-composition-event and mouse-event when mouse
 // clicking to cancel the composition.
 TEST_F(RenderWidgetHostViewAuraTest, FinishCompositionByMouse) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
   ActivateViewForTextInputManager(view_, ui::TEXT_INPUT_TYPE_TEXT);
 
   ui::CompositionText composition_text;
   composition_text.text = base::ASCIIToUTF16("|a|b");
 
   // Focused segment
   composition_text.underlines.push_back(
       ui::CompositionUnderline(0, 3, 0xff000000, true, 0x78563412));
 
@@ skipping 22 matching lines @@
     // Verify mouse event happens after the confirm-composition event.
     EXPECT_EQ(InputMsg_ImeConfirmComposition::ID,
               sink_->GetMessageAt(0)->type());
     EXPECT_EQ(InputMsg_HandleInputEvent::ID,
               sink_->GetMessageAt(1)->type());
   }
 }
 
 // Checks that touch-event state is maintained correctly.
 TEST_F(RenderWidgetHostViewAuraTest, TouchEventState) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
   GetSentMessageCountAndResetSink();
 
   // Start with no touch-event handler in the renderer.
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), 0,
                        ui::EventTimeForNow());
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 0,
                       ui::EventTimeForNow());
@@ skipping 149 matching lines @@
                          ui::EventTimeForNow());
 
   view_->OnTouchEvent(&cancel1);
   EXPECT_EQ(1U, view_->dispatcher_->GetAndResetProcessedTouchEventCount());
   EXPECT_EQ(0U, pointer_state().GetPointerCount());
 }
 
 // Checks that touch-events are queued properly when there is a touch-event
 // handler on the page.
 TEST_F(RenderWidgetHostViewAuraTest, TouchEventSyncAsync) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
 
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), 0,
                        ui::EventTimeForNow());
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 0,
                       ui::EventTimeForNow());
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), 0,
                          ui::EventTimeForNow());
@@ skipping 14 matching lines @@
   EXPECT_TRUE(move.synchronous_handling_disabled());
   EXPECT_EQ(ui::MotionEvent::ACTION_MOVE, pointer_state().GetAction());
   EXPECT_EQ(1U, pointer_state().GetPointerCount());
 
   view_->OnTouchEvent(&release);
   EXPECT_TRUE(release.synchronous_handling_disabled());
   EXPECT_EQ(0U, pointer_state().GetPointerCount());
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   sink_->ClearMessages();
   view_->SetSize(gfx::Size(100, 100));
   EXPECT_EQ("100x100", view_->GetPhysicalBackingSize().ToString());
   EXPECT_EQ(1u, sink_->message_count());
   EXPECT_EQ(ViewMsg_Resize::ID, sink_->GetMessageAt(0)->type());
   {
@@ skipping 42 matching lines @@
     EXPECT_EQ("100x100", std::get<0>(params).new_size.ToString());  // dip size
     EXPECT_EQ(
         "100x100",
         std::get<0>(params).physical_backing_size.ToString());  // backing size
   }
 }
 
 // Checks that InputMsg_CursorVisibilityChange IPC messages are dispatched
 // to the renderer at the correct times.
 TEST_F(RenderWidgetHostViewAuraTest, CursorVisibilityChange) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(gfx::Size(100, 100));
 
   aura::test::TestCursorClient cursor_client(
       parent_view_->GetNativeView()->GetRootWindow());
 
   cursor_client.AddObserver(view_);
@@ skipping 60 matching lines @@
   // a message is expected to be sent.
   sink_->ClearMessages();
   view_->Show();
   EXPECT_TRUE(sink_->GetUniqueMessageMatching(
       InputMsg_CursorVisibilityChange::ID));
 
   cursor_client.RemoveObserver(view_);
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, UpdateCursorIfOverSelf) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
 
   // Note that all coordinates in this test are screen coordinates.
   view_->SetBounds(gfx::Rect(60, 60, 100, 100));
   view_->Show();
 
   aura::test::TestCursorClient cursor_client(
@@ skipping 34 matching lines @@
                                        gfx::Size size,
                                        gfx::Rect damage) {
   cc::CompositorFrame frame;
   frame.metadata.device_scale_factor = scale_factor;
   frame.delegated_frame_data.reset(new cc::DelegatedFrameData);
 
   std::unique_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
   pass->SetNew(
       cc::RenderPassId(1, 1), gfx::Rect(size), damage, gfx::Transform());
   frame.delegated_frame_data->render_pass_list.push_back(std::move(pass));
+  if (!size.IsEmpty()) {
+    cc::TransferableResource resource;
+    resource.id = 1;
+    frame.delegated_frame_data->resource_list.push_back(std::move(resource));
+  }
   return frame;
 }
 
+// If the ui::Compositor has been reset then resources are returned back to the
+// client in response to the swap. This test verifies that the returned
+// resources are indeed reported as being in response to a swap.
+TEST_F(RenderWidgetHostViewAuraTest, ResettingCompositorReturnsResources) {
+  FakeSurfaceDamageObserver damage_observer;
+  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+  cc::SurfaceManager* manager = factory->GetSurfaceManager();
+  manager->AddObserver(&damage_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();
+
+  view_->ResetCompositor();
+
+  // Swapping a frame should trigger a swap ACK IPC because we have reset the
+  // compositor.
+  view_->OnSwapCompositorFrame(0,
+                               MakeDelegatedFrame(1.f, view_size, view_rect));
+  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));  // output_surface_id
+    EXPECT_TRUE(std::get<1>(params));    // is_swap_ack
+  }
+  manager->RemoveObserver(&damage_observer);
+}
+
+// This test verifies that returned resources do not require a pending ack.
+TEST_F(RenderWidgetHostViewAuraTest, ReturnedResources) {
+  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();
+
+  // Accumulate some returned resources. This should not trigger an IPC.
+  cc::ReturnedResourceArray resources;
+  cc::ReturnedResource resource;
+  resource.id = 1;
+  resources.push_back(resource);
+  view_->ReturnResources(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));  // output_surface_id
+    EXPECT_FALSE(std::get<1>(params));   // is_swap_ack
+  }
+}
+
+// This test verifies that when the output_surface_id changes, then
+// DelegateFrameHost returns compositor resources without a swap ack.
+TEST_F(RenderWidgetHostViewAuraTest, TwoOutputSurfaces) {
+  FakeSurfaceDamageObserver damage_observer;
+  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+  cc::SurfaceManager* manager = factory->GetSurfaceManager();
+  manager->AddObserver(&damage_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();
+
+  view_->OnSwapCompositorFrame(0,
+                               MakeDelegatedFrame(1.f, view_size, view_rect));
+
+  // Accumulate some returned resources. This should not trigger an IPC.
+  cc::ReturnedResourceArray resources;
+  cc::ReturnedResource resource;
+  resource.id = 1;
+  resources.push_back(resource);
+  view_->ReturnResources(resources);
+  EXPECT_EQ(0u, sink_->message_count());
+
+  // Swap another CompositorFrame but this time from another output_surface_id.
+  // This should trigger a non-ACK ReclaimCompositorResources IPC.
+  view_->OnSwapCompositorFrame(1,
+                               MakeDelegatedFrame(1.f, view_size, view_rect));
+  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));  // output_surface_id
+    EXPECT_FALSE(std::get<1>(params));   // is_swap_ack
+  }
+  sink_->ClearMessages();
+
+  // Report that the surface is drawn to trigger an ACK.
+  cc::Surface* surface = manager->GetSurfaceForId(view_->surface_id());
+  EXPECT_TRUE(surface);
+  surface->RunDrawCallbacks(cc::SurfaceDrawStatus::DRAWN);
+  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));    // output_surface_id
+    EXPECT_EQ(true, std::get<1>(params));  // is_swap_ack
+  }
+
+  manager->RemoveObserver(&damage_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();
   root_window->SetLayoutManager(new FullscreenLayoutManager(root_window));
   view_->InitAsFullscreen(parent_view_);
   view_->Show();
   widget_host_->ResetSizeAndRepaintPendingFlags();
   sink_->ClearMessages();
 
@@ skipping 40 matching lines @@
     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(NULL);
+  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);
 
@@ skipping 11 matching lines @@
 
   view_->window_->RemoveObserver(&observer);
 }
 
 // Recreating the layers for a window should cause Surface destruction to
 // depend on both layers.
 TEST_F(RenderWidgetHostViewAuraTest, RecreateLayers) {
   gfx::Size view_size(100, 100);
   gfx::Rect view_rect(view_size);
 
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(view_size);
   view_->Show();
 
   view_->OnSwapCompositorFrame(0,
                                MakeDelegatedFrame(1.f, view_size, view_rect));
   std::unique_ptr<ui::LayerTreeOwner> cloned_owner(
       wm::RecreateLayers(view_->GetNativeView(), nullptr));
@@ skipping 12 matching lines @@
 // 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);
 
   // Prevent the DelegatedFrameHost from skipping frames.
   view_->can_create_resize_lock_ = false;
 
-  view_->InitAsChild(NULL);
+  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, std::move(frame));
 
@@ skipping 27 matching lines @@
   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(NULL);
+  view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), root_window, gfx::Rect(size1));
   view_->Show();
   view_->SetSize(size1);
   view_->OnSwapCompositorFrame(
       0, MakeDelegatedFrame(1.f, size1, gfx::Rect(size1)));
   ui::DrawWaiterForTest::WaitForCommit(
       root_window->GetHost()->compositor());
   ViewHostMsg_UpdateRect_Params update_params;
   update_params.view_size = size1;
@@ skipping 26 matching lines @@
   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, MakeDelegatedFrame(1.f, size3, gfx::Rect(size3)));
   // Expect the frame ack;
   EXPECT_EQ(1u, sink_->message_count());
-  EXPECT_EQ(ViewMsg_SwapCompositorFrameAck::ID, sink_->GetMessageAt(0)->type());
+  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, MakeDelegatedFrame(1.f, size2, gfx::Rect(size2)));
   cc::SurfaceId surface_id = view_->surface_id();
   if (surface_id.is_null()) {
     // No frame ack yet.
@@ skipping 18 matching lines @@
         // call
         // ui::WindowEventDispatcher::SynthesizeMouseMoveAfterChangeToWindow,
         // which the above WaitForCommit may cause to be picked up. Be robust
         // to this extra IPC coming in.
         InputMsg_HandleInputEvent::Param params;
         InputMsg_HandleInputEvent::Read(msg, &params);
         const blink::WebInputEvent* event = std::get<0>(params);
         EXPECT_EQ(blink::WebInputEvent::MouseMove, event->type);
         break;
       }
-      case ViewMsg_SwapCompositorFrameAck::ID:
+      case ViewMsg_ReclaimCompositorResources::ID:
         break;
       case ViewMsg_Resize::ID: {
         EXPECT_FALSE(has_resize);
         ViewMsg_Resize::Param params;
         ViewMsg_Resize::Read(msg, &params);
         EXPECT_EQ(size3.ToString(), std::get<0>(params).new_size.ToString());
         has_resize = true;
         break;
       }
       default:
         ADD_FAILURE() << "Unexpected message " << msg->type();
         break;
     }
   }
   EXPECT_TRUE(has_resize);
   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();
 
-  view_->InitAsChild(NULL);
+  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.
@@ skipping 66 matching lines @@
   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(NULL);
+  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.
@@ skipping 20 matching lines @@
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
   view_->OnSwapCompositorFrame(3,
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   view_->window_->RemoveObserver(&observer);
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, DiscardDelegatedFrames) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
 
   size_t max_renderer_frames =
       RendererFrameManager::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, HostSharedBitmapManager::current()->AllocatedBitmapCount());
 
   std::unique_ptr<RenderWidgetHostImpl* []> hosts(
       new RenderWidgetHostImpl*[renderer_count]);
   std::unique_ptr<FakeRenderWidgetHostViewAura* []> views(
       new FakeRenderWidgetHostViewAura*[renderer_count]);
 
   // Create a bunch of renderers.
   for (size_t i = 0; i < renderer_count; ++i) {
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     hosts[i] = new RenderWidgetHostImpl(delegates_.back().get(), process_host_,
                                         routing_id, false);
     delegates_.back()->set_widget_host(hosts[i]);
     hosts[i]->Init();
     views[i] = new FakeRenderWidgetHostViewAura(hosts[i], false);
-    views[i]->InitAsChild(NULL);
+    views[i]->InitAsChild(nullptr);
     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();
@@ skipping 120 matching lines @@
   RendererFrameManager::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(NULL);
+  view_->InitAsChild(nullptr);
 
   size_t max_renderer_frames =
       RendererFrameManager::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, HostSharedBitmapManager::current()->AllocatedBitmapCount());
 
   std::unique_ptr<RenderWidgetHostImpl* []> hosts(
       new RenderWidgetHostImpl*[renderer_count]);
   std::unique_ptr<FakeRenderWidgetHostViewAura* []> views(
       new FakeRenderWidgetHostViewAura*[renderer_count]);
 
   // Create a bunch of renderers.
   for (size_t i = 0; i < renderer_count; ++i) {
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     hosts[i] = new RenderWidgetHostImpl(delegates_.back().get(), process_host_,
                                         routing_id, false);
     delegates_.back()->set_widget_host(hosts[i]);
     hosts[i]->Init();
     views[i] = new FakeRenderWidgetHostViewAura(hosts[i], false);
-    views[i]->InitAsChild(NULL);
+    views[i]->InitAsChild(nullptr);
     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. No eviction should
   // occur because all frames are visible.
   for (size_t i = 0; i < renderer_count; ++i) {
@@ skipping 22 matching lines @@
 
   for (size_t i = 0; i < renderer_count; ++i) {
     views[i]->Destroy();
     delete hosts[i];
   }
 }
 
 // Test that changing the memory pressure should delete saved frames. This test
 // only applies to ChromeOS.
 TEST_F(RenderWidgetHostViewAuraTest, DiscardDelegatedFramesWithMemoryPressure) {
-  view_->InitAsChild(NULL);
+  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(
       kMaxRendererFrames);
 
   size_t renderer_count = kMaxRendererFrames;
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size = view_rect.size();
   DCHECK_EQ(0u, HostSharedBitmapManager::current()->AllocatedBitmapCount());
 
   std::unique_ptr<RenderWidgetHostImpl* []> hosts(
       new RenderWidgetHostImpl*[renderer_count]);
   std::unique_ptr<FakeRenderWidgetHostViewAura* []> views(
       new FakeRenderWidgetHostViewAura*[renderer_count]);
 
   // Create a bunch of renderers.
   for (size_t i = 0; i < renderer_count; ++i) {
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     hosts[i] = new RenderWidgetHostImpl(delegates_.back().get(), process_host_,
                                         routing_id, false);
     delegates_.back()->set_widget_host(hosts[i]);
     hosts[i]->Init();
     views[i] = new FakeRenderWidgetHostViewAura(hosts[i], false);
-    views[i]->InitAsChild(NULL);
+    views[i]->InitAsChild(nullptr);
     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. No eviction should
   // occur because all frames are visible.
   for (size_t i = 0; i < renderer_count; ++i) {
@@ skipping 25 matching lines @@
   for (size_t i = 0; i < renderer_count; ++i) {
     views[i]->Destroy();
     delete hosts[i];
   }
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, SoftwareDPIChange) {
   gfx::Rect view_rect(100, 100);
   gfx::Size frame_size(100, 100);
 
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(view_rect.size());
   view_->Show();
 
   // With a 1x DPI UI and 1x DPI Renderer.
   view_->OnSwapCompositorFrame(
       1, MakeDelegatedFrame(1.f, frame_size, gfx::Rect(frame_size)));
@@ skipping 30 matching lines @@
   void RunLoopUntilCallback() {
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     // Temporarily ignore real draw requests.
     frame_subscriber_->set_should_capture(false);
     run_loop.Run();
     frame_subscriber_->set_should_capture(true);
   }
 
   void InitializeView() {
-    view_->InitAsChild(NULL);
+    view_->InitAsChild(nullptr);
     view_->GetDelegatedFrameHost()->SetRequestCopyOfOutputCallbackForTesting(
         base::Bind(&FakeRenderWidgetHostViewAura::InterceptCopyOfOutput,
                    base::Unretained(view_)));
     aura::client::ParentWindowWithContext(
         view_->GetNativeView(), parent_view_->GetNativeView()->GetRootWindow(),
         gfx::Rect());
     view_->SetSize(view_rect_.size());
     view_->Show();
 
     frame_subscriber_ = new FakeFrameSubscriber(
@@ skipping 207 matching lines @@
   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);
 
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(view_rect.size());
   view_->Show();
 
   // Defaults to full height of the view.
   EXPECT_EQ(100, view_->GetVisibleViewportSize().height());
 
   widget_host_->ResetSizeAndRepaintPendingFlags();
   sink_->ClearMessages();
   view_->SetInsets(gfx::Insets(0, 0, 40, 0));
 
   EXPECT_EQ(60, view_->GetVisibleViewportSize().height());
 
   const IPC::Message *message = sink_->GetFirstMessageMatching(
       ViewMsg_Resize::ID);
-  ASSERT_TRUE(message != NULL);
+  ASSERT_TRUE(message != nullptr);
 
   ViewMsg_Resize::Param params;
   ViewMsg_Resize::Read(message, &params);
   EXPECT_EQ(60, std::get<0>(params).visible_viewport_size.height());
 }
 
 // Ensures that touch event positions are never truncated to integers.
 TEST_F(RenderWidgetHostViewAuraTest, TouchEventPositionsArentRounded) {
   const float kX = 30.58f;
   const float kY = 50.23f;
 
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(), 0,
                        ui::EventTimeForNow());
   press.set_location_f(gfx::PointF(kX, kY));
   press.set_root_location_f(gfx::PointF(kX, kY));
 
   view_->OnTouchEvent(&press);
   EXPECT_EQ(ui::MotionEvent::ACTION_DOWN, pointer_state().GetAction());
   EXPECT_EQ(1U, pointer_state().GetPointerCount());
@@ skipping 950 matching lines @@
   // the host.
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        blink::WebGestureDeviceTouchscreen);
   SimulateGestureScrollUpdateEvent(300, -5, 0);
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode());
   EXPECT_EQ(2U, GetSentMessageCountAndResetSink());
 
-  view_->OnWindowFocused(NULL, view_->GetNativeView());
+  view_->OnWindowFocused(nullptr, view_->GetNativeView());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->completed_mode());
   EXPECT_EQ(0.f, overscroll_delegate()->delta_x());
   EXPECT_EQ(0.f, overscroll_delegate()->delta_y());
   sink_->ClearMessages();
 
   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
@@ skipping 12 matching lines @@
   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
   EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->completed_mode());
   EXPECT_EQ(3U, sink_->message_count());
 }
 
 // Tests that when view initiated shutdown happens (i.e. RWHView is deleted
 // before RWH), we clean up properly and don't leak the RWHVGuest.
 TEST_F(RenderWidgetHostViewGuestAuraTest, GuestViewDoesNotLeak) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   TearDownEnvironment();
   ASSERT_FALSE(guest_view_weak_.get());
 }
 
 // Tests that invalid touch events are consumed and handled
 // synchronously.
 TEST_F(RenderWidgetHostViewAuraTest,
        InvalidEventsHaveSyncHandlingDisabled) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
   GetSentMessageCountAndResetSink();
 
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), 0,
                        ui::EventTimeForNow());
 
   // Construct a move with a touch id which doesn't exist.
   ui::TouchEvent invalid_move(ui::ET_TOUCH_MOVED, gfx::Point(30, 30), 1,
                               ui::EventTimeForNow());
 
   // Valid press is handled asynchronously.
   view_->OnTouchEvent(&press);
   EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   AckLastSentInputEventIfNecessary(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // Invalid move is handled synchronously, but is consumed. It should not
   // be forwarded to the renderer.
   view_->OnTouchEvent(&invalid_move);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_FALSE(invalid_move.synchronous_handling_disabled());
   EXPECT_TRUE(invalid_move.stopped_propagation());
 }
 
 // Checks key event codes.
 TEST_F(RenderWidgetHostViewAuraTest, KeyEvent) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
 
   ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::DomCode::US_A,
                          ui::EF_NONE);
   view_->OnKeyEvent(&key_event);
 
   const NativeWebKeyboardEvent* event = delegates_.back()->last_event();
   EXPECT_NE(nullptr, event);
   if (event) {
     EXPECT_EQ(key_event.key_code(), event->windowsKeyCode);
     EXPECT_EQ(ui::KeycodeConverter::DomCodeToNativeKeycode(key_event.code()),
               event->nativeKeyCode);
   }
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, SetCanScrollForWebMouseWheelEvent) {
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
 
   sink_->ClearMessages();
 
   // Simulates the mouse wheel event with ctrl modifier applied.
   ui::MouseWheelEvent event(gfx::Vector2d(1, 1), gfx::Point(), gfx::Point(),
                             ui::EventTimeForNow(), ui::EF_CONTROL_DOWN, 0);
   view_->OnMouseEvent(&event);
 
   const WebInputEvent* input_event =
@@ skipping 159 matching lines @@
 // Tests the RenderWidgetHostImpl sends the correct surface ID namespace to
 // the renderer process.
 TEST_F(RenderWidgetHostViewAuraTest, SurfaceClientIdInitialized) {
   gfx::Size size(5, 5);
 
   const IPC::Message* msg =
       sink_->GetUniqueMessageMatching(ViewMsg_SetSurfaceClientId::ID);
   EXPECT_TRUE(msg);
   ViewMsg_SetSurfaceClientId::Param params;
   ViewMsg_SetSurfaceClientId::Read(msg, &params);
-  view_->InitAsChild(NULL);
+  view_->InitAsChild(nullptr);
   view_->Show();
   view_->SetSize(size);
   view_->OnSwapCompositorFrame(0,
                                MakeDelegatedFrame(1.f, size, gfx::Rect(size)));
   EXPECT_EQ(view_->GetSurfaceClientId(), std::get<0>(params));
 }
 
 // This class provides functionality to test a RenderWidgetHostViewAura
 // instance which has been hooked up to a test RenderViewHost instance and
 // a WebContents instance.
@@ skipping 431 matching lines @@
     // No bounds at index 1.
     EXPECT_FALSE(text_input_client()->GetCompositionCharacterBounds(1, &bound));
 
     // Valid bound at index 0.
     EXPECT_TRUE(text_input_client()->GetCompositionCharacterBounds(0, &bound));
     EXPECT_EQ(4 + (int)index, bound.height());
   }
 }
 
 }  // namespace content