Remove base::Tuple

content/browser/renderer_host/render_widget_host_view_aura_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <tuple>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 502 matching lines @@
   void AckLastSentInputEventIfNecessary(InputEventAckState ack_result) {
     if (!sink_->message_count())
       return;
 
     InputMsg_HandleInputEvent::Param params;
     if (!InputMsg_HandleInputEvent::Read(
             sink_->GetMessageAt(sink_->message_count() - 1), &params)) {
       return;
     }
 
-    InputEventDispatchType dispatch_type = base::get<2>(params);
+    InputEventDispatchType dispatch_type = std::get<2>(params);
     if (dispatch_type == InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)
       return;
 
-    const blink::WebInputEvent* event = base::get<0>(params);
+    const blink::WebInputEvent* event = std::get<0>(params);
     SendTouchEventACK(event->type, ack_result,
         WebInputEventTraits::GetUniqueTouchEventId(*event));
   }
 
   const ui::MotionEventAura& pointer_state() {
     return view_->pointer_state_for_test();
   }
 
  protected:
   // If true, then calls RWH::Shutdown() instead of deleting RWH.
@@ skipping 369 matching lines @@
       ViewHostMsg_UpdateScreenRects_ACK(widget_host_->GetRoutingID()));
   sink_->ClearMessages();
 
   // Move parents.
   parent2->SetBounds(gfx::Rect(20, 20, 200, 200));
   ASSERT_EQ(1U, sink_->message_count());
   const IPC::Message* msg = sink_->GetMessageAt(0);
   ASSERT_EQ(ViewMsg_UpdateScreenRects::ID, msg->type());
   ViewMsg_UpdateScreenRects::Param params;
   ViewMsg_UpdateScreenRects::Read(msg, &params);
-  EXPECT_EQ(gfx::Rect(24, 24, 100, 100), base::get<0>(params));
-  EXPECT_EQ(gfx::Rect(1, 1, 300, 300), base::get<1>(params));
+  EXPECT_EQ(gfx::Rect(24, 24, 100, 100), std::get<0>(params));
+  EXPECT_EQ(gfx::Rect(1, 1, 300, 300), std::get<1>(params));
   sink_->ClearMessages();
   widget_host_->OnMessageReceived(
       ViewHostMsg_UpdateScreenRects_ACK(widget_host_->GetRoutingID()));
   // There should not be any pending update.
   EXPECT_EQ(0U, sink_->message_count());
 
   parent1->SetBounds(gfx::Rect(10, 10, 300, 300));
   ASSERT_EQ(1U, sink_->message_count());
   msg = sink_->GetMessageAt(0);
   ASSERT_EQ(ViewMsg_UpdateScreenRects::ID, msg->type());
   ViewMsg_UpdateScreenRects::Read(msg, &params);
-  EXPECT_EQ(gfx::Rect(33, 33, 100, 100), base::get<0>(params));
-  EXPECT_EQ(gfx::Rect(10, 10, 300, 300), base::get<1>(params));
+  EXPECT_EQ(gfx::Rect(33, 33, 100, 100), std::get<0>(params));
+  EXPECT_EQ(gfx::Rect(10, 10, 300, 300), std::get<1>(params));
   sink_->ClearMessages();
   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_);
@@ skipping 150 matching lines @@
   view_->SetCompositionText(composition_text);
   EXPECT_TRUE(view_->has_composition_text_);
   {
     const IPC::Message* msg =
       sink_->GetFirstMessageMatching(InputMsg_ImeSetComposition::ID);
     ASSERT_TRUE(msg != NULL);
 
     InputMsg_ImeSetComposition::Param params;
     InputMsg_ImeSetComposition::Read(msg, &params);
     // composition text
-    EXPECT_EQ(composition_text.text, base::get<0>(params));
+    EXPECT_EQ(composition_text.text, std::get<0>(params));
     // underlines
-    ASSERT_EQ(underlines.size(), base::get<1>(params).size());
+    ASSERT_EQ(underlines.size(), std::get<1>(params).size());
     for (size_t i = 0; i < underlines.size(); ++i) {
-      EXPECT_EQ(underlines[i].start_offset,
-                base::get<1>(params)[i].startOffset);
-      EXPECT_EQ(underlines[i].end_offset, base::get<1>(params)[i].endOffset);
-      EXPECT_EQ(underlines[i].color, base::get<1>(params)[i].color);
-      EXPECT_EQ(underlines[i].thick, base::get<1>(params)[i].thick);
+      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,
-                base::get<1>(params)[i].backgroundColor);
+                std::get<1>(params)[i].backgroundColor);
     }
-    EXPECT_EQ(gfx::Range::InvalidRange(), base::get<2>(params));
+    EXPECT_EQ(gfx::Range::InvalidRange(), std::get<2>(params));
     // highlighted range
-    EXPECT_EQ(4, base::get<3>(params)) << "Should be the same to the caret pos";
-    EXPECT_EQ(4, base::get<4>(params)) << "Should be the same to the caret pos";
+    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);
@@ skipping 251 matching lines @@
   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());
   {
     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("100x100", base::get<0>(params).new_size.ToString());  // dip size
-    EXPECT_EQ("100x100",
-        base::get<0>(params).physical_backing_size.ToString());  // backing size
+    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
   }
 
   widget_host_->ResetSizeAndRepaintPendingFlags();
   sink_->ClearMessages();
 
   aura_test_helper_->test_screen()->SetDeviceScaleFactor(2.0f);
   EXPECT_EQ("200x200", view_->GetPhysicalBackingSize().ToString());
   // Extra ScreenInfoChanged message for |parent_view_|.
   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(2.0f, base::get<0>(params).screen_info.deviceScaleFactor);
-    EXPECT_EQ("100x100", base::get<0>(params).new_size.ToString());  // dip size
-    EXPECT_EQ("200x200",
-        base::get<0>(params).physical_backing_size.ToString());  // backing size
+    EXPECT_EQ(2.0f, std::get<0>(params).screen_info.deviceScaleFactor);
+    EXPECT_EQ("100x100", std::get<0>(params).new_size.ToString());  // dip size
+    EXPECT_EQ(
+        "200x200",
+        std::get<0>(params).physical_backing_size.ToString());  // backing size
   }
 
   widget_host_->ResetSizeAndRepaintPendingFlags();
   sink_->ClearMessages();
 
   aura_test_helper_->test_screen()->SetDeviceScaleFactor(1.0f);
   // Extra ScreenInfoChanged message for |parent_view_|.
   EXPECT_EQ(1u, sink_->message_count());
   EXPECT_EQ("100x100", view_->GetPhysicalBackingSize().ToString());
   {
     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(1.0f, base::get<0>(params).screen_info.deviceScaleFactor);
-    EXPECT_EQ("100x100", base::get<0>(params).new_size.ToString());  // dip size
-    EXPECT_EQ("100x100",
-        base::get<0>(params).physical_backing_size.ToString());  // backing size
+    EXPECT_EQ(1.0f, std::get<0>(params).screen_info.deviceScaleFactor);
+    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);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(),
       parent_view_->GetNativeView()->GetRootWindow(),
@@ skipping 143 matching lines @@
   sink_->ClearMessages();
 
   // Call WasResized to flush the old screen info.
   view_->GetRenderWidgetHost()->WasResized();
   {
     // 0 is CreatingNew message.
     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",
-              gfx::Rect(
-                  base::get<0>(params).screen_info.availableRect).ToString());
-    EXPECT_EQ("800x600", base::get<0>(params).new_size.ToString());
+    EXPECT_EQ(
+        "0,0 800x600",
+        gfx::Rect(std::get<0>(params).screen_info.availableRect).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,
-        MakeDelegatedFrame(
-            1.f, base::get<0>(params).new_size,
-            gfx::Rect(base::get<0>(params).new_size)));
+        0, 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",
-              gfx::Rect(
-                  base::get<0>(params).screen_info.availableRect).ToString());
-    EXPECT_EQ("1600x1200", base::get<0>(params).new_size.ToString());
+    EXPECT_EQ(
+        "0,0 1600x1200",
+        gfx::Rect(std::get<0>(params).screen_info.availableRect).ToString());
+    EXPECT_EQ("1600x1200", std::get<0>(params).new_size.ToString());
     view_->OnSwapCompositorFrame(
-        0,
-        MakeDelegatedFrame(
-            1.f, base::get<0>(params).new_size,
-            gfx::Rect(base::get<0>(params).new_size)));
+        0, 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);
 
@@ skipping 130 matching lines @@
 
   // Resize renderer, should produce a Resize message
   view_->SetSize(size2);
   EXPECT_EQ(size2.ToString(), view_->GetRequestedRendererSize().ToString());
   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(size2.ToString(), base::get<0>(params).new_size.ToString());
+    EXPECT_EQ(size2.ToString(), std::get<0>(params).new_size.ToString());
   }
   // Send resize ack to observe new Resize messages.
   update_params.view_size = size2;
   widget_host_->OnMessageReceived(
       ViewHostMsg_UpdateRect(widget_host_->GetRoutingID(), update_params));
   sink_->ClearMessages();
 
   // Resize renderer again, before receiving a frame. Should not produce a
   // Resize message.
   view_->SetSize(size3);
@@ skipping 34 matching lines @@
     const IPC::Message* msg = sink_->GetMessageAt(i);
     switch (msg->type()) {
       case InputMsg_HandleInputEvent::ID: {
         // On some platforms, the call to view_->Show() causes a posted task to
         // 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 = base::get<0>(params);
+        const blink::WebInputEvent* event = std::get<0>(params);
         EXPECT_EQ(blink::WebInputEvent::MouseMove, event->type);
         break;
       }
       case ViewMsg_SwapCompositorFrameAck::ID:
         break;
       case ViewMsg_Resize::ID: {
         EXPECT_FALSE(has_resize);
         ViewMsg_Resize::Param params;
         ViewMsg_Resize::Read(msg, &params);
-        EXPECT_EQ(size3.ToString(), base::get<0>(params).new_size.ToString());
+        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;
@@ skipping 736 matching lines @@
   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);
 
   ViewMsg_Resize::Param params;
   ViewMsg_Resize::Read(message, &params);
-  EXPECT_EQ(60, base::get<0>(params).visible_viewport_size.height());
+  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_->Show();
 
@@ skipping 1707 matching lines @@
   const IPC::Message* msg =
       sink_->GetUniqueMessageMatching(ViewMsg_SetSurfaceIdNamespace::ID);
   EXPECT_TRUE(msg);
   ViewMsg_SetSurfaceIdNamespace::Param params;
   ViewMsg_SetSurfaceIdNamespace::Read(msg, &params);
   view_->InitAsChild(NULL);
   view_->Show();
   view_->SetSize(size);
   view_->OnSwapCompositorFrame(0,
                                MakeDelegatedFrame(1.f, size, gfx::Rect(size)));
-  EXPECT_EQ(view_->GetSurfaceIdNamespace(), base::get<0>(params));
+  EXPECT_EQ(view_->GetSurfaceIdNamespace(), 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.
 class RenderWidgetHostViewAuraWithViewHarnessTest
     : public RenderViewHostImplTestHarness {
  public:
    RenderWidgetHostViewAuraWithViewHarnessTest()
       : view_(nullptr) {}
@@ skipping 138 matching lines @@
   view()->OnGestureEvent(&gesture_event);
 
   EXPECT_TRUE(delegate->context_menu_request_received());
   EXPECT_EQ(delegate->context_menu_source_type(), ui::MENU_SOURCE_TOUCH);
 #endif
 
   RenderViewHostFactory::set_is_real_render_view_host(false);
 }
 
 }  // namespace content