Revert of De-dupe copy requests for tab capture in DelegatedFrameHost.

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 "base/basictypes.h"
 #include "base/command_line.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/browser/browser_thread_impl.h"
@@ skipping 2032 matching lines @@
   else
     EXPECT_NE(surface_id, view_->surface_id());
 }
 
 class RenderWidgetHostViewAuraCopyRequestTest
     : public RenderWidgetHostViewAuraShutdownTest {
  public:
   RenderWidgetHostViewAuraCopyRequestTest()
       : callback_count_(0), result_(false) {}
 
-  void CallbackMethod(bool result) {
+  void CallbackMethod(const base::Closure& quit_closure, bool result) {
     result_ = result;
     callback_count_++;
-    quit_closure_.Run();
-  }
-
-  void RunLoopUntilCallback() {
-    base::RunLoop run_loop;
-    quit_closure_ = run_loop.QuitClosure();
-    run_loop.Run();
+    quit_closure.Run();
   }
 
   int callback_count_;
   bool result_;
 
  private:
-  base::Closure quit_closure_;
-
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraCopyRequestTest);
 };
 
-// Tests that only one copy/readback request will be executed per one browser
-// composite operation, even when multiple render frame swaps occur in between
-// browser composites, and even if the frame subscriber desires more frames than
-// the number of browser composites.
-TEST_F(RenderWidgetHostViewAuraCopyRequestTest, DedupeFrameSubscriberRequests) {
+TEST_F(RenderWidgetHostViewAuraCopyRequestTest, DestroyedAfterCopyRequest) {
+  base::RunLoop run_loop;
+
   gfx::Rect view_rect(100, 100);
   scoped_ptr<cc::CopyOutputRequest> request;
 
   view_->InitAsChild(NULL);
   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();
 
-  view_->BeginFrameSubscription(make_scoped_ptr(new FakeFrameSubscriber(
-      view_rect.size(),
-      base::Bind(&RenderWidgetHostViewAuraCopyRequestTest::CallbackMethod,
-                 base::Unretained(this)))).Pass());
-  int expected_callback_count = 0;
-  ASSERT_EQ(expected_callback_count, callback_count_);
-  ASSERT_FALSE(view_->last_copy_request_);
-
-  // Normal case: A browser composite executes for each render frame swap.
-  for (int i = 0; i < 3; ++i) {
-    // Renderer provides another frame.
-    view_->OnSwapCompositorFrame(
-        1, MakeDelegatedFrame(1.f, view_rect.size(), gfx::Rect(view_rect)));
-    ASSERT_TRUE(view_->last_copy_request_);
-    request = view_->last_copy_request_.Pass();
-
-    // Browser composites with the frame, executing the copy request, and then
-    // the result is delivered.
-    view_->GetDelegatedFrameHost()->OnCompositingStarted(
-        nullptr, base::TimeTicks::Now());
-    request->SendTextureResult(view_rect.size(),
-                               request->texture_mailbox(),
-                               scoped_ptr<cc::SingleReleaseCallback>());
-    view_->GetDelegatedFrameHost()->OnCompositingEnded(nullptr);
-    RunLoopUntilCallback();
-
-    // The callback should be run with success status.
-    ++expected_callback_count;
-    ASSERT_EQ(expected_callback_count, callback_count_);
-    EXPECT_TRUE(result_);
-  }
-
-  // De-duping cases: 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.
-    cc::CopyOutputRequest* the_only_request = nullptr;
-    for (int j = 0; j < num_swaps; ++j) {
-      view_->OnSwapCompositorFrame(
-          1, MakeDelegatedFrame(1.f, view_rect.size(), gfx::Rect(view_rect)));
-      ASSERT_TRUE(view_->last_copy_request_);
-      if (the_only_request)
-        ASSERT_EQ(the_only_request, view_->last_copy_request_.get());
-      else
-        the_only_request = view_->last_copy_request_.get();
-      if (j > 0) {
-        ++expected_callback_count;
-        ASSERT_EQ(expected_callback_count, callback_count_);
-        EXPECT_FALSE(result_);  // The prior copy request was aborted.
-      }
-      if (j == (num_swaps - 1))
-        request = view_->last_copy_request_.Pass();
-    }
-
-    // Browser composites with the frame, executing the de-duped copy request,
-    // and then the result is delivered.
-    view_->GetDelegatedFrameHost()->OnCompositingStarted(
-        nullptr, base::TimeTicks::Now());
-    request->SendTextureResult(view_rect.size(),
-                               request->texture_mailbox(),
-                               scoped_ptr<cc::SingleReleaseCallback>());
-    view_->GetDelegatedFrameHost()->OnCompositingEnded(nullptr);
-    RunLoopUntilCallback();
-
-    // The final callback should be run with success status.
-    ++expected_callback_count;
-    ASSERT_EQ(expected_callback_count, callback_count_);
-    EXPECT_TRUE(result_);
-  }
-
-  // Multiple de-duped copy requests in-flight.
-  for (int i = 0; i < 3; ++i) {
-    const int num_in_flight = 1 + i % 3;
-    ScopedVector<cc::CopyOutputRequest> requests;
-
-    for (int j = 0; j < num_in_flight; ++j) {
-      // Renderer provides another frame.
-      view_->OnSwapCompositorFrame(
-          1, MakeDelegatedFrame(1.f, view_rect.size(), gfx::Rect(view_rect)));
-      ASSERT_TRUE(view_->last_copy_request_);
-      requests.push_back(view_->last_copy_request_.Pass());
-
-      // Browser composites with the frame, but the response to the copy request
-      // is delayed.
-      view_->GetDelegatedFrameHost()->OnCompositingStarted(
-          nullptr, base::TimeTicks::Now());
-      view_->GetDelegatedFrameHost()->OnCompositingEnded(nullptr);
-      ASSERT_EQ(expected_callback_count, callback_count_);
-    }
-
-    // Deliver each response, and expect success.
-    for (cc::CopyOutputRequest* r : requests) {
-      r->SendTextureResult(view_rect.size(),
-                           request->texture_mailbox(),
-                           scoped_ptr<cc::SingleReleaseCallback>());
-      RunLoopUntilCallback();
-      ++expected_callback_count;
-      ASSERT_EQ(expected_callback_count, callback_count_);
-      EXPECT_TRUE(result_);
-    }
-  }
-
-  // Destroy the RenderWidgetHostViewAura and ImageTransportFactory.
-  TearDownEnvironment();
-}
-
-TEST_F(RenderWidgetHostViewAuraCopyRequestTest, DestroyedAfterCopyRequest) {
-  gfx::Rect view_rect(100, 100);
-  scoped_ptr<cc::CopyOutputRequest> request;
-
-  view_->InitAsChild(NULL);
-  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();
-
   scoped_ptr<FakeFrameSubscriber> frame_subscriber(new FakeFrameSubscriber(
       view_rect.size(),
       base::Bind(&RenderWidgetHostViewAuraCopyRequestTest::CallbackMethod,
-                 base::Unretained(this))));
+                 base::Unretained(this),
+                 run_loop.QuitClosure())));
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_FALSE(view_->last_copy_request_);
 
   view_->BeginFrameSubscription(frame_subscriber.Pass());
   view_->OnSwapCompositorFrame(
       1, MakeDelegatedFrame(1.f, view_rect.size(), gfx::Rect(view_rect)));
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_TRUE(view_->last_copy_request_);
   EXPECT_TRUE(view_->last_copy_request_->has_texture_mailbox());
   request = view_->last_copy_request_.Pass();
 
-  // Notify DelegatedFrameHost that the graphics commands were issued by calling
-  // OnCompositingStarted().  This clears the "frame subscriber de-duping" flag.
-  view_->GetDelegatedFrameHost()->OnCompositingStarted(nullptr,
-                                                       base::TimeTicks::Now());
   // Send back the mailbox included in the request. There's no release callback
   // since the mailbox came from the RWHVA originally.
   request->SendTextureResult(view_rect.size(),
                              request->texture_mailbox(),
                              scoped_ptr<cc::SingleReleaseCallback>());
-  view_->GetDelegatedFrameHost()->OnCompositingEnded(nullptr);
-  RunLoopUntilCallback();
+
+  // This runs until the callback happens.
+  run_loop.Run();
 
   // The callback should succeed.
   EXPECT_EQ(1, callback_count_);
   EXPECT_TRUE(result_);
 
   view_->OnSwapCompositorFrame(
       1, MakeDelegatedFrame(1.f, view_rect.size(), gfx::Rect(view_rect)));
 
   EXPECT_EQ(1, callback_count_);
   request = view_->last_copy_request_.Pass();
 
   // Destroy the RenderWidgetHostViewAura and ImageTransportFactory.
   TearDownEnvironment();
 
-  // The DelegatedFrameHost should have run all remaining callbacks from its
-  // destructor.
-  EXPECT_EQ(2, callback_count_);
-  EXPECT_FALSE(result_);
-
-  // Send the result after-the-fact.  It goes nowhere since DelegatedFrameHost
-  // has been destroyed.
+  // Send back the mailbox included in the request. There's no release callback
+  // since the mailbox came from the RWHVA originally.
   request->SendTextureResult(view_rect.size(),
                              request->texture_mailbox(),
                              scoped_ptr<cc::SingleReleaseCallback>());
+
+  // Because the copy request callback may be holding state within it, that
+  // state must handle the RWHVA and ImageTransportFactory going away before the
+  // callback is called. This test passes if it does not crash as a result of
+  // these things being destroyed.
   EXPECT_EQ(2, callback_count_);
   EXPECT_FALSE(result_);
 }
 
 TEST_F(RenderWidgetHostViewAuraTest, VisibleViewportTest) {
   gfx::Rect view_rect(100, 100);
 
   view_->InitAsChild(NULL);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
@@ skipping 1065 matching lines @@
   ui::TouchEvent press2(
       ui::ET_TOUCH_PRESSED, gfx::Point(20, 20), 1, ui::EventTimeForNow());
   view_->OnTouchEvent(&press2);
   SendInputEventACK(blink::WebInputEvent::TouchStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(2U, view_->dispatcher_->processed_touch_event_count());
 }
 
 }  // namespace content