Update legacy Tuple-using code.

chrome/renderer/printing/print_web_view_helper_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/command_line.h"
 #include "base/run_loop.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/print_messages.h"
 #include "chrome/renderer/printing/mock_printer.h"
 #include "chrome/renderer/printing/print_web_view_helper.h"
@@ skipping 133 matching lines @@
     // always print all pages, and there are checks to that effect built into
     // the print code.
 #else
     const IPC::Message* page_cnt_msg =
         render_thread_->sink().GetUniqueMessageMatching(
             PrintHostMsg_DidGetPrintedPagesCount::ID);
     ASSERT_TRUE(page_cnt_msg);
     PrintHostMsg_DidGetPrintedPagesCount::Param post_page_count_param;
     PrintHostMsg_DidGetPrintedPagesCount::Read(page_cnt_msg,
                                                &post_page_count_param);
-    EXPECT_EQ(count, post_page_count_param.b);
+    EXPECT_EQ(count, get<1>(post_page_count_param));
 #endif  // defined(OS_CHROMEOS)
   }
 
   // The renderer should be done calculating the number of rendered pages
   // according to the specified settings defined in the mock render thread.
   // Verify the page count is correct.
   void VerifyPreviewPageCount(int count) {
     const IPC::Message* page_cnt_msg =
         render_thread_->sink().GetUniqueMessageMatching(
         PrintHostMsg_DidGetPreviewPageCount::ID);
     ASSERT_TRUE(page_cnt_msg);
     PrintHostMsg_DidGetPreviewPageCount::Param post_page_count_param;
     PrintHostMsg_DidGetPreviewPageCount::Read(page_cnt_msg,
                                               &post_page_count_param);
-    EXPECT_EQ(count, post_page_count_param.a.page_count);
+    EXPECT_EQ(count, get<0>(post_page_count_param).page_count);
   }
 
   // Verifies whether the pages printed or not.
   void VerifyPagesPrinted(bool printed) {
 #if defined(OS_CHROMEOS)
     bool did_print_msg = (render_thread_->sink().GetUniqueMessageMatching(
         PrintHostMsg_TempFileForPrintingWritten::ID) != NULL);
     ASSERT_EQ(printed, did_print_msg);
 #else
     const IPC::Message* print_msg =
         render_thread_->sink().GetUniqueMessageMatching(
             PrintHostMsg_DidPrintPage::ID);
     bool did_print_msg = (NULL != print_msg);
     ASSERT_EQ(printed, did_print_msg);
     if (printed) {
       PrintHostMsg_DidPrintPage::Param post_did_print_page_param;
       PrintHostMsg_DidPrintPage::Read(print_msg, &post_did_print_page_param);
-      EXPECT_EQ(0, post_did_print_page_param.a.page_number);
+      EXPECT_EQ(0, get<0>(post_did_print_page_param).page_number);
     }
 #endif  // defined(OS_CHROMEOS)
   }
 
 #if defined(ENABLE_BASIC_PRINTING)
   void OnPrintPages() {
     PrintWebViewHelper::Get(view_)->OnPrintPages();
     ProcessPendingMessages();
   }
 #endif  // ENABLE_BASIC_PRINTING
@@ skipping 289 matching lines @@
 
   void VerifyPrintPreviewGenerated(bool generated_preview) {
     const IPC::Message* preview_msg =
         render_thread_->sink().GetUniqueMessageMatching(
             PrintHostMsg_MetafileReadyForPrinting::ID);
     bool did_get_preview_msg = (NULL != preview_msg);
     ASSERT_EQ(generated_preview, did_get_preview_msg);
     if (did_get_preview_msg) {
       PrintHostMsg_MetafileReadyForPrinting::Param preview_param;
       PrintHostMsg_MetafileReadyForPrinting::Read(preview_msg, &preview_param);
-      EXPECT_NE(0, preview_param.a.document_cookie);
-      EXPECT_NE(0, preview_param.a.expected_pages_count);
-      EXPECT_NE(0U, preview_param.a.data_size);
+      EXPECT_NE(0, get<0>(preview_param).document_cookie);
+      EXPECT_NE(0, get<0>(preview_param).expected_pages_count);
+      EXPECT_NE(0U, get<0>(preview_param).data_size);
     }
   }
 
   void VerifyPrintFailed(bool did_fail) {
     bool print_failed = (render_thread_->sink().GetUniqueMessageMatching(
         PrintHostMsg_PrintingFailed::ID) != NULL);
     EXPECT_EQ(did_fail, print_failed);
   }
 
   void VerifyPrintPreviewInvalidPrinterSettings(bool settings_invalid) {
     bool print_preview_invalid_printer_settings =
         (render_thread_->sink().GetUniqueMessageMatching(
             PrintHostMsg_PrintPreviewInvalidPrinterSettings::ID) != NULL);
     EXPECT_EQ(settings_invalid, print_preview_invalid_printer_settings);
   }
 
   // |page_number| is 0-based.
   void VerifyDidPreviewPage(bool generate_draft_pages, int page_number) {
     bool msg_found = false;
     size_t msg_count = render_thread_->sink().message_count();
     for (size_t i = 0; i < msg_count; ++i) {
       const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
       if (msg->type() == PrintHostMsg_DidPreviewPage::ID) {
         PrintHostMsg_DidPreviewPage::Param page_param;
         PrintHostMsg_DidPreviewPage::Read(msg, &page_param);
-        if (page_param.a.page_number == page_number) {
+        if (get<0>(page_param).page_number == page_number) {
           msg_found = true;
           if (generate_draft_pages)
-            EXPECT_NE(0U, page_param.a.data_size);
+            EXPECT_NE(0U, get<0>(page_param).data_size);
           else
-            EXPECT_EQ(0U, page_param.a.data_size);
+            EXPECT_EQ(0U, get<0>(page_param).data_size);
           break;
         }
       }
     }
     ASSERT_EQ(generate_draft_pages, msg_found);
   }
 
   void VerifyDefaultPageLayout(int content_width, int content_height,
                                int margin_top, int margin_bottom,
                                int margin_left, int margin_right,
                                bool page_has_print_css) {
     const IPC::Message* default_page_layout_msg =
         render_thread_->sink().GetUniqueMessageMatching(
             PrintHostMsg_DidGetDefaultPageLayout::ID);
     bool did_get_default_page_layout_msg = (NULL != default_page_layout_msg);
     if (did_get_default_page_layout_msg) {
       PrintHostMsg_DidGetDefaultPageLayout::Param param;
       PrintHostMsg_DidGetDefaultPageLayout::Read(default_page_layout_msg,
                                                  &param);
-      EXPECT_EQ(content_width, param.a.content_width);
-      EXPECT_EQ(content_height, param.a.content_height);
-      EXPECT_EQ(margin_top, param.a.margin_top);
-      EXPECT_EQ(margin_right, param.a.margin_right);
-      EXPECT_EQ(margin_left, param.a.margin_left);
-      EXPECT_EQ(margin_bottom, param.a.margin_bottom);
-      EXPECT_EQ(page_has_print_css, param.c);
+      EXPECT_EQ(content_width, get<0>(param).content_width);
+      EXPECT_EQ(content_height, get<0>(param).content_height);
+      EXPECT_EQ(margin_top, get<0>(param).margin_top);
+      EXPECT_EQ(margin_right, get<0>(param).margin_right);
+      EXPECT_EQ(margin_left, get<0>(param).margin_left);
+      EXPECT_EQ(margin_bottom, get<0>(param).margin_bottom);
+      EXPECT_EQ(page_has_print_css, get<2>(param));
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(PrintWebViewHelperPreviewTest);
 };
 
 #if defined(ENABLE_PRINT_PREVIEW)
 TEST_F(PrintWebViewHelperPreviewTest, BlockScriptInitiatedPrinting) {
   LoadHTML(kHelloWorldHTML);
   PrintWebViewHelper* print_web_view_helper = PrintWebViewHelper::Get(view_);
@@ skipping 421 matching lines @@
   CreatePrintSettingsDictionary(&dict);
   OnPrintForPrintPreview(dict);
 
   VerifyPrintFailed(true);
   VerifyPagesPrinted(false);
 }
 
 #endif  // !defined(OS_CHROMEOS)
 
 }  // namespace printing