Move Tuple to base namespace.

content/renderer/render_view_browsertest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 388 matching lines @@
       "data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=";
 
   view()->saveImageFromDataURL(WebString::fromUTF8(image_data_url));
   ProcessPendingMessages();
   const IPC::Message* msg2 = render_thread_->sink().GetFirstMessageMatching(
       ViewHostMsg_SaveImageFromDataURL::ID);
   EXPECT_TRUE(msg2);
 
   ViewHostMsg_SaveImageFromDataURL::Param param1;
   ViewHostMsg_SaveImageFromDataURL::Read(msg2, &param1);
-  EXPECT_EQ(get<1>(param1).length(), image_data_url.length());
-  EXPECT_EQ(get<1>(param1), image_data_url);
+  EXPECT_EQ(base::get<1>(param1).length(), image_data_url.length());
+  EXPECT_EQ(base::get<1>(param1), image_data_url);
 
   ProcessPendingMessages();
   render_thread_->sink().ClearMessages();
 
   const std::string large_data_url(1024 * 1024 * 10 - 1, 'd');
 
   view()->saveImageFromDataURL(WebString::fromUTF8(large_data_url));
   ProcessPendingMessages();
   const IPC::Message* msg3 = render_thread_->sink().GetFirstMessageMatching(
       ViewHostMsg_SaveImageFromDataURL::ID);
   EXPECT_TRUE(msg3);
 
   ViewHostMsg_SaveImageFromDataURL::Param param2;
   ViewHostMsg_SaveImageFromDataURL::Read(msg3, &param2);
-  EXPECT_EQ(get<1>(param2).length(), large_data_url.length());
-  EXPECT_EQ(get<1>(param2), large_data_url);
+  EXPECT_EQ(base::get<1>(param2).length(), large_data_url.length());
+  EXPECT_EQ(base::get<1>(param2), large_data_url);
 
   ProcessPendingMessages();
   render_thread_->sink().ClearMessages();
 
   const std::string exceeded_data_url(1024 * 1024 * 10 + 1, 'd');
 
   view()->saveImageFromDataURL(WebString::fromUTF8(exceeded_data_url));
   ProcessPendingMessages();
   const IPC::Message* msg4 = render_thread_->sink().GetFirstMessageMatching(
       ViewHostMsg_SaveImageFromDataURL::ID);
@@ skipping 44 matching lines @@
   ProcessPendingMessages();
 
   const IPC::Message* frame_navigate_msg =
       render_thread_->sink().GetUniqueMessageMatching(
           FrameHostMsg_DidCommitProvisionalLoad::ID);
   EXPECT_TRUE(frame_navigate_msg);
 
   FrameHostMsg_DidCommitProvisionalLoad::Param host_nav_params;
   FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg,
                                               &host_nav_params);
-  EXPECT_TRUE(get<0>(host_nav_params).is_post);
+  EXPECT_TRUE(base::get<0>(host_nav_params).is_post);
 
   // Check post data sent to browser matches
-  EXPECT_TRUE(get<0>(host_nav_params).page_state.IsValid());
+  EXPECT_TRUE(base::get<0>(host_nav_params).page_state.IsValid());
   scoped_ptr<HistoryEntry> entry =
-      PageStateToHistoryEntry(get<0>(host_nav_params).page_state);
+      PageStateToHistoryEntry(base::get<0>(host_nav_params).page_state);
   blink::WebHTTPBody body = entry->root().httpBody();
   blink::WebHTTPBody::Element element;
   bool successful = body.elementAt(0, element);
   EXPECT_TRUE(successful);
   EXPECT_EQ(blink::WebHTTPBody::Element::TypeData, element.type);
   EXPECT_EQ(length, element.data.size());
   EXPECT_EQ(0, memcmp(raw_data, element.data.data(), length));
 }
 
 TEST_F(RenderViewImplTest, DecideNavigationPolicy) {
@@ skipping 185 matching lines @@
   // Load page B, which will trigger an UpdateState message for page A.
   LoadHTML("<div>Page B</div>");
 
   // Check for a valid UpdateState message for page A.
   ProcessPendingMessages();
   const IPC::Message* msg_A = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_A);
   ViewHostMsg_UpdateState::Param params;
   ViewHostMsg_UpdateState::Read(msg_A, &params);
-  int page_id_A = get<0>(params);
-  PageState state_A = get<1>(params);
+  int page_id_A = base::get<0>(params);
+  PageState state_A = base::get<1>(params);
   EXPECT_EQ(1, page_id_A);
   render_thread_->sink().ClearMessages();
 
   // Back to page A (page_id 1) and commit.
   CommonNavigationParams common_params_A;
   RequestNavigationParams request_params_A;
   common_params_A.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params_A.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   request_params_A.current_history_list_length = 2;
   request_params_A.current_history_list_offset = 1;
@@ skipping 37 matching lines @@
   // Verify page A committed, not swappedout://.
   const IPC::Message* frame_navigate_msg =
       render_thread_->sink().GetUniqueMessageMatching(
           FrameHostMsg_DidCommitProvisionalLoad::ID);
   EXPECT_TRUE(frame_navigate_msg);
 
   // Read URL out of the parent trait of the params object.
   FrameHostMsg_DidCommitProvisionalLoad::Param commit_load_params;
   FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg,
                                               &commit_load_params);
-  EXPECT_NE(GURL("swappedout://"), get<0>(commit_load_params).url);
+  EXPECT_NE(GURL("swappedout://"), base::get<0>(commit_load_params).url);
 }
 
 // Verify that security origins are replicated properly to RenderFrameProxies
 // when swapping out.
 TEST_F(RenderViewImplTest, OriginReplicationForSwapOut) {
   // This test should only run with --site-per-process, since origin
   // replication only happens in that mode.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSitePerProcess))
     return;
@@ skipping 39 matching lines @@
   // Load page B, which will trigger an UpdateState message for page A.
   LoadHTML("<div>Page B</div>");
 
   // Check for a valid UpdateState message for page A.
   ProcessPendingMessages();
   const IPC::Message* msg_A = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_A);
   ViewHostMsg_UpdateState::Param param;
   ViewHostMsg_UpdateState::Read(msg_A, &param);
-  int page_id_A = get<0>(param);
-  PageState state_A = get<1>(param);
+  int page_id_A = base::get<0>(param);
+  PageState state_A = base::get<1>(param);
   EXPECT_EQ(1, page_id_A);
   render_thread_->sink().ClearMessages();
 
   // Load page C, which will trigger an UpdateState message for page B.
   LoadHTML("<div>Page C</div>");
 
   // Check for a valid UpdateState for page B.
   ProcessPendingMessages();
   const IPC::Message* msg_B = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_B);
   ViewHostMsg_UpdateState::Read(msg_B, &param);
-  int page_id_B = get<0>(param);
-  PageState state_B = get<1>(param);
+  int page_id_B = base::get<0>(param);
+  PageState state_B = base::get<1>(param);
   EXPECT_EQ(2, page_id_B);
   EXPECT_NE(state_A, state_B);
   render_thread_->sink().ClearMessages();
 
   // Load page D, which will trigger an UpdateState message for page C.
   LoadHTML("<div>Page D</div>");
 
   // Check for a valid UpdateState for page C.
   ProcessPendingMessages();
   const IPC::Message* msg_C = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_C);
   ViewHostMsg_UpdateState::Read(msg_C, &param);
-  int page_id_C = get<0>(param);
-  PageState state_C = get<1>(param);
+  int page_id_C = base::get<0>(param);
+  PageState state_C = base::get<1>(param);
   EXPECT_EQ(3, page_id_C);
   EXPECT_NE(state_B, state_C);
   render_thread_->sink().ClearMessages();
 
   // Go back to C and commit, preparing for our real test.
   CommonNavigationParams common_params_C;
   RequestNavigationParams request_params_C;
   common_params_C.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params_C.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   request_params_C.current_history_list_length = 4;
@@ skipping 33 matching lines @@
   request_params.page_state = state_A;
   NavigateMainFrame(common_params, StartNavigationParams(), request_params);
   ProcessPendingMessages();
 
   // Now ensure that the UpdateState message we receive is consistent
   // and represents page C in both page_id and state.
   const IPC::Message* msg = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg);
   ViewHostMsg_UpdateState::Read(msg, &param);
-  int page_id = get<0>(param);
-  PageState state = get<1>(param);
+  int page_id = base::get<0>(param);
+  PageState state = base::get<1>(param);
   EXPECT_EQ(page_id_C, page_id);
   EXPECT_NE(state_A, state);
   EXPECT_NE(state_B, state);
   EXPECT_EQ(state_C, state);
 }
 
 // Test that stale back/forward navigations arriving from the browser are
 // ignored.  See http://crbug.com/86758.
 TEST_F(RenderViewImplTest, StaleNavigationsIgnored) {
   // Load page A.
   LoadHTML("<div id=pagename>Page A</div>");
   EXPECT_EQ(1, view()->history_list_length_);
   EXPECT_EQ(0, view()->history_list_offset_);
 
   // Load page B, which will trigger an UpdateState message for page A.
   LoadHTML("<div id=pagename>Page B</div>");
   EXPECT_EQ(2, view()->history_list_length_);
   EXPECT_EQ(1, view()->history_list_offset_);
 
   // Check for a valid UpdateState message for page A.
   ProcessPendingMessages();
   const IPC::Message* msg_A = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_A);
   ViewHostMsg_UpdateState::Param param;
   ViewHostMsg_UpdateState::Read(msg_A, &param);
-  int page_id_A = get<0>(param);
-  PageState state_A = get<1>(param);
+  int page_id_A = base::get<0>(param);
+  PageState state_A = base::get<1>(param);
   EXPECT_EQ(1, page_id_A);
   render_thread_->sink().ClearMessages();
 
   // Back to page A (nav_entry_id 1) and commit.
   CommonNavigationParams common_params_A;
   RequestNavigationParams request_params_A;
   common_params_A.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   common_params_A.transition = ui::PAGE_TRANSITION_FORWARD_BACK;
   request_params_A.current_history_list_length = 2;
   request_params_A.current_history_list_offset = 1;
@@ skipping 108 matching lines @@
     render_thread_->sink().ClearMessages();
 
     // Update the IME status and verify if our IME backend sends an IPC message
     // to activate IMEs.
     view()->UpdateTextInputType();
     const IPC::Message* msg = render_thread_->sink().GetMessageAt(0);
     EXPECT_TRUE(msg != NULL);
     EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type());
     ViewHostMsg_TextInputTypeChanged::Param params;
     ViewHostMsg_TextInputTypeChanged::Read(msg, &params);
-    ui::TextInputType type = get<0>(params);
-    ui::TextInputMode input_mode = get<1>(params);
-    bool can_compose_inline = get<2>(params);
+    ui::TextInputType type = base::get<0>(params);
+    ui::TextInputMode input_mode = base::get<1>(params);
+    bool can_compose_inline = base::get<2>(params);
     EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, type);
     EXPECT_EQ(true, can_compose_inline);
 
     // Move the input focus to the second <input> element, where we should
     // de-activate IMEs.
     ExecuteJavaScript("document.getElementById('test2').focus();");
     ProcessPendingMessages();
     render_thread_->sink().ClearMessages();
 
     // Update the IME status and verify if our IME backend sends an IPC message
     // to de-activate IMEs.
     view()->UpdateTextInputType();
     msg = render_thread_->sink().GetMessageAt(0);
     EXPECT_TRUE(msg != NULL);
     EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type());
     ViewHostMsg_TextInputTypeChanged::Read(msg, & params);
-    type = get<0>(params);
-    input_mode = get<1>(params);
+    type = base::get<0>(params);
+    input_mode = base::get<1>(params);
     EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, type);
 
     for (size_t i = 0; i < arraysize(kInputModeTestCases); i++) {
       const InputModeTestCase* test_case = &kInputModeTestCases[i];
       std::string javascript =
           base::StringPrintf("document.getElementById('%s').focus();",
                              test_case->input_id);
       // Move the input focus to the target <input> element, where we should
       // activate IMEs.
       ExecuteJavaScriptAndReturnIntValue(base::ASCIIToUTF16(javascript), NULL);
       ProcessPendingMessages();
       render_thread_->sink().ClearMessages();
 
       // Update the IME status and verify if our IME backend sends an IPC
       // message to activate IMEs.
       view()->UpdateTextInputType();
       const IPC::Message* msg = render_thread_->sink().GetMessageAt(0);
       EXPECT_TRUE(msg != NULL);
       EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type());
       ViewHostMsg_TextInputTypeChanged::Read(msg, & params);
-      type = get<0>(params);
-      input_mode = get<1>(params);
+      type = base::get<0>(params);
+      input_mode = base::get<1>(params);
       EXPECT_EQ(test_case->expected_mode, input_mode);
     }
   }
 }
 
 // Test that our IME backend can compose CJK words.
 // Our IME front-end sends many platform-independent messages to the IME backend
 // while it composes CJK words. This test sends the minimal messages captured
 // on my local environment directly to the IME backend to verify if the backend
 // can compose CJK words without any problems.
@@ skipping 1104 matching lines @@
   LoadHTML("<input id='test1' value='hello1'></input>"
            "<input id='test2' value='hello2'></input>");
 
   ExecuteJavaScript("document.getElementById('test1').focus();");
   const IPC::Message* msg1 = render_thread_->sink().GetFirstMessageMatching(
       ViewHostMsg_FocusedNodeChanged::ID);
   EXPECT_TRUE(msg1);
 
   ViewHostMsg_FocusedNodeChanged::Param params;
   ViewHostMsg_FocusedNodeChanged::Read(msg1, &params);
-  EXPECT_TRUE(get<0>(params));
+  EXPECT_TRUE(base::get<0>(params));
   render_thread_->sink().ClearMessages();
 
   ExecuteJavaScript("document.getElementById('test2').focus();");
   const IPC::Message* msg2 = render_thread_->sink().GetFirstMessageMatching(
         ViewHostMsg_FocusedNodeChanged::ID);
   EXPECT_TRUE(msg2);
   ViewHostMsg_FocusedNodeChanged::Read(msg2, &params);
-  EXPECT_TRUE(get<0>(params));
+  EXPECT_TRUE(base::get<0>(params));
   render_thread_->sink().ClearMessages();
 
   view()->webview()->clearFocusedElement();
   const IPC::Message* msg3 = render_thread_->sink().GetFirstMessageMatching(
         ViewHostMsg_FocusedNodeChanged::ID);
   EXPECT_TRUE(msg3);
   ViewHostMsg_FocusedNodeChanged::Read(msg3, &params);
-  EXPECT_FALSE(get<0>(params));
+  EXPECT_FALSE(base::get<0>(params));
   render_thread_->sink().ClearMessages();
 }
 
 TEST_F(RenderViewImplTest, ServiceWorkerNetworkProviderSetup) {
   ServiceWorkerNetworkProvider* provider = NULL;
   RequestExtraData* extra_data = NULL;
 
   // Make sure each new document has a new provider and
   // that the main request is tagged with the provider's id.
   LoadHTML("<b>A Document</b>");
@@ skipping 175 matching lines @@
       FROM_HERE,
       base::Bind(&DevToolsAgentTest::CloseWhilePaused, base::Unretained(this)));
   ExecuteJavaScript("debugger;");
 
   // CloseWhilePaused should resume execution and continue here.
   EXPECT_FALSE(IsPaused());
   Detach();
 }
 
 }  // namespace content