Update legacy Tuple-using code.

BUG=440675
TEST=no change
R=mdempsky@chromium.org, thakis@chromium.org
TBR=ben@chromium.org

Review URL: https://codereview.chromium.org/821453003

Cr-Commit-Position: refs/heads/master@{#309441}

78 files changed, 474 insertions, 531 deletions

diff --git a/base/memory/raw_scoped_refptr_mismatch_checker.h b/base/memory/raw_scoped_refptr_mismatch_checker.h
index 7974f30..0190558 100644
--- a/base/memory/raw_scoped_refptr_mismatch_checker.h
+++ b/base/memory/raw_scoped_refptr_mismatch_checker.h
@@ -47,30 +47,30 @@ struct ParamsUseScopedRefptrCorrectly {
 };
 
 template <>
-struct ParamsUseScopedRefptrCorrectly<Tuple0> {
+struct ParamsUseScopedRefptrCorrectly<Tuple<>> {
   enum { value = 1 };
 };
 
 template <typename A>
-struct ParamsUseScopedRefptrCorrectly<Tuple1<A> > {
+struct ParamsUseScopedRefptrCorrectly<Tuple<A>> {
   enum { value = !NeedsScopedRefptrButGetsRawPtr<A>::value };
 };
 
 template <typename A, typename B>
-struct ParamsUseScopedRefptrCorrectly<Tuple2<A, B> > {
+struct ParamsUseScopedRefptrCorrectly<Tuple<A, B>> {
   enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
                    NeedsScopedRefptrButGetsRawPtr<B>::value) };
 };
 
 template <typename A, typename B, typename C>
-struct ParamsUseScopedRefptrCorrectly<Tuple3<A, B, C> > {
+struct ParamsUseScopedRefptrCorrectly<Tuple<A, B, C>> {
   enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
                    NeedsScopedRefptrButGetsRawPtr<B>::value ||
                    NeedsScopedRefptrButGetsRawPtr<C>::value) };
 };
 
 template <typename A, typename B, typename C, typename D>
-struct ParamsUseScopedRefptrCorrectly<Tuple4<A, B, C, D> > {
+struct ParamsUseScopedRefptrCorrectly<Tuple<A, B, C, D>> {
   enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
                    NeedsScopedRefptrButGetsRawPtr<B>::value ||
                    NeedsScopedRefptrButGetsRawPtr<C>::value ||
@@ -78,7 +78,7 @@ struct ParamsUseScopedRefptrCorrectly<Tuple4<A, B, C, D> > {
 };
 
 template <typename A, typename B, typename C, typename D, typename E>
-struct ParamsUseScopedRefptrCorrectly<Tuple5<A, B, C, D, E> > {
+struct ParamsUseScopedRefptrCorrectly<Tuple<A, B, C, D, E>> {
   enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
                    NeedsScopedRefptrButGetsRawPtr<B>::value ||
                    NeedsScopedRefptrButGetsRawPtr<C>::value ||
@@ -88,7 +88,7 @@ struct ParamsUseScopedRefptrCorrectly<Tuple5<A, B, C, D, E> > {
 
 template <typename A, typename B, typename C, typename D, typename E,
           typename F>
-struct ParamsUseScopedRefptrCorrectly<Tuple6<A, B, C, D, E, F> > {
+struct ParamsUseScopedRefptrCorrectly<Tuple<A, B, C, D, E, F>> {
   enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
                    NeedsScopedRefptrButGetsRawPtr<B>::value ||
                    NeedsScopedRefptrButGetsRawPtr<C>::value ||
@@ -99,7 +99,7 @@ struct ParamsUseScopedRefptrCorrectly<Tuple6<A, B, C, D, E, F> > {
 
 template <typename A, typename B, typename C, typename D, typename E,
           typename F, typename G>
-struct ParamsUseScopedRefptrCorrectly<Tuple7<A, B, C, D, E, F, G> > {
+struct ParamsUseScopedRefptrCorrectly<Tuple<A, B, C, D, E, F, G>> {
   enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
                    NeedsScopedRefptrButGetsRawPtr<B>::value ||
                    NeedsScopedRefptrButGetsRawPtr<C>::value ||
@@ -111,7 +111,7 @@ struct ParamsUseScopedRefptrCorrectly<Tuple7<A, B, C, D, E, F, G> > {
 
 template <typename A, typename B, typename C, typename D, typename E,
           typename F, typename G, typename H>
-struct ParamsUseScopedRefptrCorrectly<Tuple8<A, B, C, D, E, F, G, H> > {
+struct ParamsUseScopedRefptrCorrectly<Tuple<A, B, C, D, E, F, G, H>> {
   enum { value = !(NeedsScopedRefptrButGetsRawPtr<A>::value ||
                    NeedsScopedRefptrButGetsRawPtr<B>::value ||
                    NeedsScopedRefptrButGetsRawPtr<C>::value ||
diff --git a/base/observer_list_threadsafe.h b/base/observer_list_threadsafe.h
index 70b4f11..ff4843e 100644
--- a/base/observer_list_threadsafe.h
+++ b/base/observer_list_threadsafe.h
@@ -169,35 +169,35 @@ class ObserverListThreadSafe
   // been Notified.  The notification may still be pending delivery.
   template <class Method>
   void Notify(Method m) {
-    UnboundMethod<ObserverType, Method, Tuple0> method(m, MakeTuple());
-    Notify<Method, Tuple0>(method);
+    UnboundMethod<ObserverType, Method, Tuple<>> method(m, MakeTuple());
+    Notify<Method, Tuple<>>(method);
   }
 
   template <class Method, class A>
   void Notify(Method m, const A& a) {
-    UnboundMethod<ObserverType, Method, Tuple1<A> > method(m, MakeTuple(a));
-    Notify<Method, Tuple1<A> >(method);
+    UnboundMethod<ObserverType, Method, Tuple<A> > method(m, MakeTuple(a));
+    Notify<Method, Tuple<A> >(method);
   }
 
   template <class Method, class A, class B>
   void Notify(Method m, const A& a, const B& b) {
-    UnboundMethod<ObserverType, Method, Tuple2<A, B> > method(
+    UnboundMethod<ObserverType, Method, Tuple<A, B> > method(
         m, MakeTuple(a, b));
-    Notify<Method, Tuple2<A, B> >(method);
+    Notify<Method, Tuple<A, B> >(method);
   }
 
   template <class Method, class A, class B, class C>
   void Notify(Method m, const A& a, const B& b, const C& c) {
-    UnboundMethod<ObserverType, Method, Tuple3<A, B, C> > method(
+    UnboundMethod<ObserverType, Method, Tuple<A, B, C> > method(
         m, MakeTuple(a, b, c));
-    Notify<Method, Tuple3<A, B, C> >(method);
+    Notify<Method, Tuple<A, B, C> >(method);
   }
 
   template <class Method, class A, class B, class C, class D>
   void Notify(Method m, const A& a, const B& b, const C& c, const D& d) {
-    UnboundMethod<ObserverType, Method, Tuple4<A, B, C, D> > method(
+    UnboundMethod<ObserverType, Method, Tuple<A, B, C, D> > method(
         m, MakeTuple(a, b, c, d));
-    Notify<Method, Tuple4<A, B, C, D> >(method);
+    Notify<Method, Tuple<A, B, C, D> >(method);
   }
 
   // TODO(mbelshe):  Add more wrappers for Notify() with more arguments.
diff --git a/base/tuple.h b/base/tuple.h
index a0d2245..4408074 100644
--- a/base/tuple.h
+++ b/base/tuple.h
@@ -124,71 +124,6 @@ struct TupleLeaf {
   T x;
 };
 
-// For legacy compatibility, we name the first 8 tuple elements "a", "b", ...
-// TODO(mdempsky): Update users to use get<N>() (crbug.com/440675).
-
-#define DEFINE_TUPLE_LEAF(N, x)                                        \
-  template <typename T>                                                \
-  struct TupleLeaf<N, T> {                                             \
-    TupleLeaf() {}                                                     \
-    explicit TupleLeaf(typename TupleTraits<T>::ParamType x) : x(x) {} \
-                                                                       \
-    T& get() { return x; }                                             \
-    const T& get() const { return x; }                                 \
-                                                                       \
-    T x;                                                               \
-  }
-
-DEFINE_TUPLE_LEAF(0, a);
-DEFINE_TUPLE_LEAF(1, b);
-DEFINE_TUPLE_LEAF(2, c);
-DEFINE_TUPLE_LEAF(3, d);
-DEFINE_TUPLE_LEAF(4, e);
-DEFINE_TUPLE_LEAF(5, f);
-DEFINE_TUPLE_LEAF(6, g);
-DEFINE_TUPLE_LEAF(7, h);
-
-#undef DEFINE_TUPLE_LEAF
-
-// Deprecated compat aliases
-// TODO(mdempsky): Update users to just use Tuple instead (crbug.com/440675).
-
-using Tuple0 = Tuple<>;
-template <typename A>
-using Tuple1 = Tuple<A>;
-template <typename A, typename B>
-using Tuple2 = Tuple<A, B>;
-template <typename A, typename B, typename C>
-using Tuple3 = Tuple<A, B, C>;
-template <typename A, typename B, typename C, typename D>
-using Tuple4 = Tuple<A, B, C, D>;
-template <typename A, typename B, typename C, typename D, typename E>
-using Tuple5 = Tuple<A, B, C, D, E>;
-template <typename A,
-          typename B,
-          typename C,
-          typename D,
-          typename E,
-          typename F>
-using Tuple6 = Tuple<A, B, C, D, E, F>;
-template <typename A,
-          typename B,
-          typename C,
-          typename D,
-          typename E,
-          typename F,
-          typename G>
-using Tuple7 = Tuple<A, B, C, D, E, F, G>;
-template <typename A,
-          typename B,
-          typename C,
-          typename D,
-          typename E,
-          typename F,
-          typename G,
-          typename H>
-using Tuple8 = Tuple<A, B, C, D, E, F, G, H>;
-
 // Tuple getters --------------------------------------------------------------
 //
 // Allows accessing an arbitrary tuple element by index.
diff --git a/base/tuple_unittest.cc b/base/tuple_unittest.cc
index 8d620de..5b43aff 100644
--- a/base/tuple_unittest.cc
+++ b/base/tuple_unittest.cc
@@ -30,50 +30,50 @@ struct Addz {
 }  // namespace
 
 TEST(TupleTest, Basic) {
-  Tuple0 t0 = MakeTuple();
+  Tuple<> t0 = MakeTuple();
   ALLOW_UNUSED_LOCAL(t0);
-  Tuple1<int> t1(1);
-  Tuple2<int, const char*> t2 = MakeTuple(1, static_cast<const char*>("wee"));
-  Tuple3<int, int, int> t3(1, 2, 3);
-  Tuple4<int, int, int, int*> t4(1, 2, 3, &t1.a);
-  Tuple5<int, int, int, int, int*> t5(1, 2, 3, 4, &t4.a);
-  Tuple6<int, int, int, int, int, int*> t6(1, 2, 3, 4, 5, &t4.a);
-
-  EXPECT_EQ(1, t1.a);
-  EXPECT_EQ(1, t2.a);
-  EXPECT_EQ(1, t3.a);
-  EXPECT_EQ(2, t3.b);
-  EXPECT_EQ(3, t3.c);
-  EXPECT_EQ(1, t4.a);
-  EXPECT_EQ(2, t4.b);
-  EXPECT_EQ(3, t4.c);
-  EXPECT_EQ(1, t5.a);
-  EXPECT_EQ(2, t5.b);
-  EXPECT_EQ(3, t5.c);
-  EXPECT_EQ(4, t5.d);
-  EXPECT_EQ(1, t6.a);
-  EXPECT_EQ(2, t6.b);
-  EXPECT_EQ(3, t6.c);
-  EXPECT_EQ(4, t6.d);
-  EXPECT_EQ(5, t6.e);
-
-  EXPECT_EQ(1, t1.a);
+  Tuple<int> t1(1);
+  Tuple<int, const char*> t2 = MakeTuple(1, static_cast<const char*>("wee"));
+  Tuple<int, int, int> t3(1, 2, 3);
+  Tuple<int, int, int, int*> t4(1, 2, 3, &get<0>(t1));
+  Tuple<int, int, int, int, int*> t5(1, 2, 3, 4, &get<0>(t4));
+  Tuple<int, int, int, int, int, int*> t6(1, 2, 3, 4, 5, &get<0>(t4));
+
+  EXPECT_EQ(1, get<0>(t1));
+  EXPECT_EQ(1, get<0>(t2));
+  EXPECT_EQ(1, get<0>(t3));
+  EXPECT_EQ(2, get<1>(t3));
+  EXPECT_EQ(3, get<2>(t3));
+  EXPECT_EQ(1, get<0>(t4));
+  EXPECT_EQ(2, get<1>(t4));
+  EXPECT_EQ(3, get<2>(t4));
+  EXPECT_EQ(1, get<0>(t5));
+  EXPECT_EQ(2, get<1>(t5));
+  EXPECT_EQ(3, get<2>(t5));
+  EXPECT_EQ(4, get<3>(t5));
+  EXPECT_EQ(1, get<0>(t6));
+  EXPECT_EQ(2, get<1>(t6));
+  EXPECT_EQ(3, get<2>(t6));
+  EXPECT_EQ(4, get<3>(t6));
+  EXPECT_EQ(5, get<4>(t6));
+
+  EXPECT_EQ(1, get<0>(t1));
   DispatchToFunction(&DoAdd, t4);
-  EXPECT_EQ(6, t1.a);
+  EXPECT_EQ(6, get<0>(t1));
 
   int res = 0;
   DispatchToFunction(&DoAdd, MakeTuple(9, 8, 7, &res));
   EXPECT_EQ(24, res);
 
   Addy addy;
-  EXPECT_EQ(1, t4.a);
+  EXPECT_EQ(1, get<0>(t4));
   DispatchToMethod(&addy, &Addy::DoAdd, t5);
-  EXPECT_EQ(10, t4.a);
+  EXPECT_EQ(10, get<0>(t4));
 
   Addz addz;
-  EXPECT_EQ(10, t4.a);
+  EXPECT_EQ(10, get<0>(t4));
   DispatchToMethod(&addz, &Addz::DoAdd, t6);
-  EXPECT_EQ(15, t4.a);
+  EXPECT_EQ(15, get<0>(t4));
 }
 
 namespace {
@@ -108,8 +108,8 @@ TEST(TupleTest, Copying) {
   bool res = false;
 
   // Creating the tuple should copy the class to store internally in the tuple.
-  Tuple3<CopyLogger, CopyLogger*, bool*> tuple(logger, &logger, &res);
-  tuple.b = &tuple.a;
+  Tuple<CopyLogger, CopyLogger*, bool*> tuple(logger, &logger, &res);
+  get<1>(tuple) = &get<0>(tuple);
   EXPECT_EQ(2, CopyLogger::TimesConstructed);
   EXPECT_EQ(1, CopyLogger::TimesCopied);
 
diff --git a/chrome/browser/apps/app_shim/app_shim_host_mac_unittest.cc b/chrome/browser/apps/app_shim/app_shim_host_mac_unittest.cc
index 9b8b9d9..6ad92a5 100644
--- a/chrome/browser/apps/app_shim/app_shim_host_mac_unittest.cc
+++ b/chrome/browser/apps/app_shim/app_shim_host_mac_unittest.cc
@@ -74,7 +74,7 @@ class AppShimHostTest : public testing::Test,
     EXPECT_EQ(AppShimMsg_LaunchApp_Done::ID, message->type());
     AppShimMsg_LaunchApp_Done::Param param;
     AppShimMsg_LaunchApp_Done::Read(message, &param);
-    return param.a;
+    return get<0>(param);
   }
 
   void SimulateDisconnect() {
diff --git a/chrome/browser/extensions/api/alarms/alarms_api_unittest.cc b/chrome/browser/extensions/api/alarms/alarms_api_unittest.cc
index c5f4e83..9a95fb9 100644
--- a/chrome/browser/extensions/api/alarms/alarms_api_unittest.cc
+++ b/chrome/browser/extensions/api/alarms/alarms_api_unittest.cc
@@ -284,8 +284,8 @@ TEST_F(ExtensionAlarmsTest, CreateDelayBelowMinimum) {
   ASSERT_TRUE(warning);
   ExtensionMsg_AddMessageToConsole::Param params;
   ExtensionMsg_AddMessageToConsole::Read(warning, &params);
-  content::ConsoleMessageLevel level = params.a;
-  std::string message = params.b;
+  content::ConsoleMessageLevel level = get<0>(params);
+  std::string message = get<1>(params);
   EXPECT_EQ(content::CONSOLE_MESSAGE_LEVEL_WARNING, level);
   EXPECT_THAT(message, testing::HasSubstr("delay is less than minimum of 1"));
 }
diff --git a/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc b/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
index 046b672..26d0867 100644
--- a/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
+++ b/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
@@ -120,9 +120,9 @@ void GetPartOfMessageArguments(IPC::Message* message,
                                ExtensionMsg_MessageInvoke::Param* param) {
   ASSERT_EQ(ExtensionMsg_MessageInvoke::ID, message->type());
   ASSERT_TRUE(ExtensionMsg_MessageInvoke::Read(message, param));
-  ASSERT_GE(param->d.GetSize(), 2u);
+  ASSERT_GE(get<3>(*param).GetSize(), 2u);
   const base::Value* value = NULL;
-  ASSERT_TRUE(param->d.Get(1, &value));
+  ASSERT_TRUE(get<3>(*param).Get(1, &value));
   const base::ListValue* list = NULL;
   ASSERT_TRUE(value->GetAsList(&list));
   ASSERT_EQ(1u, list->GetSize());
@@ -920,7 +920,7 @@ TEST_P(ExtensionWebRequestHeaderModificationTest, TestModifications) {
       continue;
     ExtensionMsg_MessageInvoke::Param message_tuple;
     ExtensionMsg_MessageInvoke::Read(message, &message_tuple);
-    base::ListValue& args = message_tuple.d;
+    base::ListValue& args = get<3>(message_tuple);
 
     std::string event_name;
     if (!args.GetString(0, &event_name) ||
diff --git a/chrome/browser/extensions/sandboxed_unpacker.cc b/chrome/browser/extensions/sandboxed_unpacker.cc
index 8079749..b2c6a3b 100644
--- a/chrome/browser/extensions/sandboxed_unpacker.cc
+++ b/chrome/browser/extensions/sandboxed_unpacker.cc
@@ -712,8 +712,8 @@ bool SandboxedUnpacker::RewriteImageFiles(SkBitmap* install_icon) {
       return false;
     }
 
-    const SkBitmap& image = images[i].a;
-    base::FilePath path_suffix = images[i].b;
+    const SkBitmap& image = get<0>(images[i]);
+    base::FilePath path_suffix = get<1>(images[i]);
     if (path_suffix.MaybeAsASCII() == install_icon_path)
       *install_icon = image;
 
diff --git a/chrome/browser/password_manager/chrome_password_manager_client_unittest.cc b/chrome/browser/password_manager/chrome_password_manager_client_unittest.cc
index 3690362..0a0ad29 100644
--- a/chrome/browser/password_manager/chrome_password_manager_client_unittest.cc
+++ b/chrome/browser/password_manager/chrome_password_manager_client_unittest.cc
@@ -105,9 +105,9 @@ bool ChromePasswordManagerClientTest::WasLoggingActivationMessageSent(
       process()->sink().GetFirstMessageMatching(kMsgID);
   if (!message)
     return false;
-  Tuple1<bool> param;
+  Tuple<bool> param;
   AutofillMsg_SetLoggingState::Read(message, &param);
-  *activation_flag = param.a;
+  *activation_flag = get<0>(param);
   process()->sink().ClearMessages();
   return true;
 }
diff --git a/chrome/browser/safe_browsing/client_side_detection_host_unittest.cc b/chrome/browser/safe_browsing/client_side_detection_host_unittest.cc
index 52396ec..9fd2f7d 100644
--- a/chrome/browser/safe_browsing/client_side_detection_host_unittest.cc
+++ b/chrome/browser/safe_browsing/client_side_detection_host_unittest.cc
@@ -330,9 +330,9 @@ class ClientSideDetectionHostTest : public ChromeRenderViewHostTestHarness {
         SafeBrowsingMsg_StartPhishingDetection::ID);
     if (url) {
       ASSERT_TRUE(msg);
-      Tuple1<GURL> actual_url;
+      Tuple<GURL> actual_url;
       SafeBrowsingMsg_StartPhishingDetection::Read(msg, &actual_url);
-      EXPECT_EQ(*url, actual_url.a);
+      EXPECT_EQ(*url, get<0>(actual_url));
       EXPECT_EQ(rvh()->GetRoutingID(), msg->routing_id());
       process()->sink().ClearMessages();
     } else {
diff --git a/chrome/browser/search/instant_service_unittest.cc b/chrome/browser/search/instant_service_unittest.cc
index bacd7ae..0d488df 100644
--- a/chrome/browser/search/instant_service_unittest.cc
+++ b/chrome/browser/search/instant_service_unittest.cc
@@ -108,8 +108,8 @@ TEST_F(InstantServiceEnabledTest, SendsSearchURLsToRenderer) {
   ASSERT_TRUE(msg);
   ChromeViewMsg_SetSearchURLs::Param params;
   ChromeViewMsg_SetSearchURLs::Read(msg, &params);
-  std::vector<GURL> search_urls = params.a;
-  GURL new_tab_page_url = params.b;
+  std::vector<GURL> search_urls = get<0>(params);
+  GURL new_tab_page_url = get<1>(params);
   EXPECT_EQ(2U, search_urls.size());
   EXPECT_EQ("https://www.google.com/alt#quux=", search_urls[0].spec());
   EXPECT_EQ("https://www.google.com/url?bar=", search_urls[1].spec());
diff --git a/chrome/browser/spellchecker/spellcheck_message_filter_mac_browsertest.cc b/chrome/browser/spellchecker/spellcheck_message_filter_mac_browsertest.cc
index 6dc759f..52aecec 100644
--- a/chrome/browser/spellchecker/spellcheck_message_filter_mac_browsertest.cc
+++ b/chrome/browser/spellchecker/spellcheck_message_filter_mac_browsertest.cc
@@ -52,7 +52,7 @@ IN_PROC_BROWSER_TEST_F(SpellCheckMessageFilterMacBrowserTest,
   SpellCheckMsg_RespondTextCheck::Param params;
   bool ok = SpellCheckMsg_RespondTextCheck::Read(
       target->sent_messages_[0], &params);
-  std::vector<SpellCheckResult> sent_results = params.b;
+  std::vector<SpellCheckResult> sent_results = get<1>(params);
  
   EXPECT_TRUE(ok);
   EXPECT_EQ(1U, sent_results.size());
diff --git a/chrome/browser/spellchecker/spellcheck_message_filter_unittest.cc b/chrome/browser/spellchecker/spellcheck_message_filter_unittest.cc
index fc750a5..0e98efe 100644
--- a/chrome/browser/spellchecker/spellcheck_message_filter_unittest.cc
+++ b/chrome/browser/spellchecker/spellcheck_message_filter_unittest.cc
@@ -103,11 +103,11 @@ TEST(SpellCheckMessageFilterTest, OnTextCheckCompleteTestCustomDictionary) {
 
   SpellCheckMsg_RespondSpellingService::Param params;
   bool ok = SpellCheckMsg_RespondSpellingService::Read(
-      filter->sent_messages[0], & params);
-  int sent_identifier = params.a;
-  bool sent_success = params.b;
-  base::string16 sent_text = params.c;
-  std::vector<SpellCheckResult> sent_results = params.d;
+      filter->sent_messages[0], &params);
+  int sent_identifier = get<0>(params);
+  bool sent_success = get<1>(params);
+  base::string16 sent_text = get<2>(params);
+  std::vector<SpellCheckResult> sent_results = get<3>(params);
   EXPECT_TRUE(ok);
   EXPECT_EQ(kCallbackId, sent_identifier);
   EXPECT_EQ(kSuccess, sent_success);
@@ -135,8 +135,8 @@ TEST(SpellCheckMessageFilterTest, OnTextCheckCompleteTest) {
   SpellCheckMsg_RespondSpellingService::Param params;
   bool ok = SpellCheckMsg_RespondSpellingService::Read(
       filter->sent_messages[0], & params);
-  base::string16 sent_text = params.c;
-  std::vector<SpellCheckResult> sent_results = params.d;
+  base::string16 sent_text = get<2>(params);
+  std::vector<SpellCheckResult> sent_results = get<3>(params);
   EXPECT_TRUE(ok);
   EXPECT_EQ(static_cast<size_t>(2), sent_results.size());
 }
diff --git a/chrome/browser/translate/translate_manager_render_view_host_unittest.cc b/chrome/browser/translate/translate_manager_render_view_host_unittest.cc
index 4f207d4..a9d805b 100644
--- a/chrome/browser/translate/translate_manager_render_view_host_unittest.cc
+++ b/chrome/browser/translate/translate_manager_render_view_host_unittest.cc
@@ -135,14 +135,14 @@ class TranslateManagerRenderViewHostTest
         ChromeViewMsg_TranslatePage::ID);
     if (!message)
       return false;
-    Tuple4<int, std::string, std::string, std::string> translate_param;
+    Tuple<int, std::string, std::string, std::string> translate_param;
     ChromeViewMsg_TranslatePage::Read(message, &translate_param);
-    // Ignore translate_param.a which is the page seq no.
-    // Ignore translate_param.b which is the script injected in the page.
+    // Ignore get<0>(translate_param) which is the page seq no.
+    // Ignore get<1>(translate_param) which is the script injected in the page.
     if (original_lang)
-      *original_lang = translate_param.c;
+      *original_lang = get<2>(translate_param);
     if (target_lang)
-      *target_lang = translate_param.d;
+      *target_lang = get<3>(translate_param);
     return true;
   }
 
diff --git a/chrome/browser/ui/search/instant_search_prerenderer_unittest.cc b/chrome/browser/ui/search/instant_search_prerenderer_unittest.cc
index 7008a6a..f40a294 100644
--- a/chrome/browser/ui/search/instant_search_prerenderer_unittest.cc
+++ b/chrome/browser/ui/search/instant_search_prerenderer_unittest.cc
@@ -501,12 +501,13 @@ TEST_F(TestUsePrerenderPage, SetEmbeddedSearchRequestParams) {
   ASSERT_TRUE(message);
 
   // Verify the IPC message params.
-  Tuple2<base::string16, EmbeddedSearchRequestParams> params;
+  Tuple<base::string16, EmbeddedSearchRequestParams> params;
   ChromeViewMsg_SearchBoxSubmit::Read(message, &params);
-  EXPECT_EQ("foo", base::UTF16ToASCII(params.a));
-  EXPECT_EQ("f", base::UTF16ToASCII(params.b.original_query));
-  EXPECT_EQ("utf-8", base::UTF16ToASCII(params.b.input_encoding));
-  EXPECT_EQ("", base::UTF16ToASCII(params.b.rlz_parameter_value));
-  EXPECT_EQ("chrome...0", base::UTF16ToASCII(params.b.assisted_query_stats));
+  EXPECT_EQ("foo", base::UTF16ToASCII(get<0>(params)));
+  EXPECT_EQ("f", base::UTF16ToASCII(get<1>(params).original_query));
+  EXPECT_EQ("utf-8", base::UTF16ToASCII(get<1>(params).input_encoding));
+  EXPECT_EQ("", base::UTF16ToASCII(get<1>(params).rlz_parameter_value));
+  EXPECT_EQ("chrome...0",
+            base::UTF16ToASCII(get<1>(params).assisted_query_stats));
 }
 #endif
diff --git a/chrome/browser/ui/search/search_ipc_router_unittest.cc b/chrome/browser/ui/search/search_ipc_router_unittest.cc
index 8c09eb9..81096d0 100644
--- a/chrome/browser/ui/search/search_ipc_router_unittest.cc
+++ b/chrome/browser/ui/search/search_ipc_router_unittest.cc
@@ -160,10 +160,10 @@ class SearchIPCRouterTest : public BrowserWithTestWindowTest {
     const IPC::Message* message = process()->sink().GetFirstMessageMatching(
         ChromeViewMsg_SearchBoxSetDisplayInstantResults::ID);
     EXPECT_NE(static_cast<const IPC::Message*>(NULL), message);
-    Tuple1<bool> display_instant_results_param;
+    Tuple<bool> display_instant_results_param;
     ChromeViewMsg_SearchBoxSetDisplayInstantResults::Read(
         message, &display_instant_results_param);
-    EXPECT_EQ(expected_param_value, display_instant_results_param.a);
+    EXPECT_EQ(expected_param_value, get<0>(display_instant_results_param));
   }
 
   MockSearchIPCRouterDelegate* mock_delegate() { return &delegate_; }
diff --git a/chrome/browser/ui/search/search_tab_helper_unittest.cc b/chrome/browser/ui/search/search_tab_helper_unittest.cc
index ffd587e..0264ae2 100644
--- a/chrome/browser/ui/search/search_tab_helper_unittest.cc
+++ b/chrome/browser/ui/search/search_tab_helper_unittest.cc
@@ -189,8 +189,8 @@ TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMatch) {
 
   ChromeViewMsg_ChromeIdentityCheckResult::Param params;
   ChromeViewMsg_ChromeIdentityCheckResult::Read(message, &params);
-  EXPECT_EQ(test_identity, params.a);
-  ASSERT_TRUE(params.b);
+  EXPECT_EQ(test_identity, get<0>(params));
+  ASSERT_TRUE(get<1>(params));
 }
 
 TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMismatch) {
@@ -209,8 +209,8 @@ TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMismatch) {
 
   ChromeViewMsg_ChromeIdentityCheckResult::Param params;
   ChromeViewMsg_ChromeIdentityCheckResult::Read(message, &params);
-  EXPECT_EQ(test_identity, params.a);
-  ASSERT_FALSE(params.b);
+  EXPECT_EQ(test_identity, get<0>(params));
+  ASSERT_FALSE(get<1>(params));
 }
 
 TEST_F(SearchTabHelperTest, OnChromeIdentityCheckSignedOutMismatch) {
@@ -229,8 +229,8 @@ TEST_F(SearchTabHelperTest, OnChromeIdentityCheckSignedOutMismatch) {
 
   ChromeViewMsg_ChromeIdentityCheckResult::Param params;
   ChromeViewMsg_ChromeIdentityCheckResult::Read(message, &params);
-  EXPECT_EQ(test_identity, params.a);
-  ASSERT_FALSE(params.b);
+  EXPECT_EQ(test_identity, get<0>(params));
+  ASSERT_FALSE(get<1>(params));
 }
 
 TEST_F(SearchTabHelperTest, OnHistorySyncCheckSyncInactive) {
@@ -250,7 +250,7 @@ TEST_F(SearchTabHelperTest, OnHistorySyncCheckSyncInactive) {
 
   ChromeViewMsg_HistorySyncCheckResult::Param params;
   ChromeViewMsg_HistorySyncCheckResult::Read(message, &params);
-  ASSERT_FALSE(params.a);
+  ASSERT_FALSE(get<0>(params));
 }
 
 TEST_F(SearchTabHelperTest, OnHistorySyncCheckSyncing) {
@@ -268,7 +268,7 @@ TEST_F(SearchTabHelperTest, OnHistorySyncCheckSyncing) {
 
   ChromeViewMsg_HistorySyncCheckResult::Param params;
   ChromeViewMsg_HistorySyncCheckResult::Read(message, &params);
-  ASSERT_TRUE(params.a);
+  ASSERT_TRUE(get<0>(params));
 }
 
 TEST_F(SearchTabHelperTest, OnHistorySyncCheckNotSyncing) {
@@ -286,7 +286,7 @@ TEST_F(SearchTabHelperTest, OnHistorySyncCheckNotSyncing) {
 
   ChromeViewMsg_HistorySyncCheckResult::Param params;
   ChromeViewMsg_HistorySyncCheckResult::Read(message, &params);
-  ASSERT_FALSE(params.a);
+  ASSERT_FALSE(get<0>(params));
 }
 
 class TabTitleObserver : public content::WebContentsObserver {
diff --git a/chrome/renderer/autofill/autofill_renderer_browsertest.cc b/chrome/renderer/autofill/autofill_renderer_browsertest.cc
index cd1c8d3..7ef6566 100644
--- a/chrome/renderer/autofill/autofill_renderer_browsertest.cc
+++ b/chrome/renderer/autofill/autofill_renderer_browsertest.cc
@@ -36,11 +36,11 @@ using blink::WebVector;
 
 namespace autofill {
 
-typedef Tuple5<int,
-               autofill::FormData,
-               autofill::FormFieldData,
-               gfx::RectF,
-               bool> AutofillQueryParam;
+typedef Tuple<int,
+              autofill::FormData,
+              autofill::FormFieldData,
+              gfx::RectF,
+              bool> AutofillQueryParam;
 
 class AutofillRendererTest : public ChromeRenderViewTest {
  public:
@@ -88,7 +88,7 @@ TEST_F(AutofillRendererTest, SendForms) {
   ASSERT_NE(nullptr, message);
   AutofillHostMsg_FormsSeen::Param params;
   AutofillHostMsg_FormsSeen::Read(message, &params);
-  std::vector<FormData> forms = params.a;
+  std::vector<FormData> forms = get<0>(params);
   ASSERT_EQ(1UL, forms.size());
   ASSERT_EQ(4UL, forms[0].fields.size());
 
@@ -151,7 +151,7 @@ TEST_F(AutofillRendererTest, SendForms) {
       AutofillHostMsg_FormsSeen::ID);
   ASSERT_NE(nullptr, message);
   AutofillHostMsg_FormsSeen::Read(message, &params);
-  forms = params.a;
+  forms = get<0>(params);
   ASSERT_EQ(1UL, forms.size());
   ASSERT_EQ(3UL, forms[0].fields.size());
 
@@ -183,7 +183,7 @@ TEST_F(AutofillRendererTest, EnsureNoFormSeenIfTooFewFields) {
   ASSERT_NE(nullptr, message);
   AutofillHostMsg_FormsSeen::Param params;
   AutofillHostMsg_FormsSeen::Read(message, &params);
-  const std::vector<FormData>& forms = params.a;
+  const std::vector<FormData>& forms = get<0>(params);
   ASSERT_EQ(0UL, forms.size());
 }
 
@@ -218,7 +218,7 @@ TEST_F(AutofillRendererTest, ShowAutofillWarning) {
 
   AutofillQueryParam query_param;
   AutofillHostMsg_QueryFormFieldAutofill::Read(message1, &query_param);
-  EXPECT_FALSE(query_param.e);
+  EXPECT_FALSE(get<4>(query_param));
   render_thread_->sink().ClearMessages();
 
   // Simulate attempting to Autofill the form from the second element, which
@@ -232,7 +232,7 @@ TEST_F(AutofillRendererTest, ShowAutofillWarning) {
   ASSERT_NE(nullptr, message2);
 
   AutofillHostMsg_QueryFormFieldAutofill::Read(message2, &query_param);
-  EXPECT_TRUE(query_param.e);
+  EXPECT_TRUE(get<4>(query_param));
 }
 
 // Regression test for [ http://crbug.com/346010 ].
@@ -264,7 +264,7 @@ TEST_F(AutofillRendererTest, DynamicallyAddedUnownedFormElements) {
   ASSERT_NE(nullptr, message);
   AutofillHostMsg_FormsSeen::Param params;
   AutofillHostMsg_FormsSeen::Read(message, &params);
-  std::vector<FormData> forms = params.a;
+  std::vector<FormData> forms = get<0>(params);
   ASSERT_EQ(1UL, forms.size());
   ASSERT_EQ(7UL, forms[0].fields.size());
 
@@ -277,7 +277,7 @@ TEST_F(AutofillRendererTest, DynamicallyAddedUnownedFormElements) {
       AutofillHostMsg_FormsSeen::ID);
   ASSERT_NE(nullptr, message);
   AutofillHostMsg_FormsSeen::Read(message, &params);
-  forms = params.a;
+  forms = get<0>(params);
   ASSERT_EQ(1UL, forms.size());
   ASSERT_EQ(9UL, forms[0].fields.size());
 
diff --git a/chrome/renderer/autofill/form_autocomplete_browsertest.cc b/chrome/renderer/autofill/form_autocomplete_browsertest.cc
index 5f49d9d..0c05648 100644
--- a/chrome/renderer/autofill/form_autocomplete_browsertest.cc
+++ b/chrome/renderer/autofill/form_autocomplete_browsertest.cc
@@ -36,15 +36,15 @@ TEST_F(FormAutocompleteTest, NormalFormSubmit) {
   ASSERT_TRUE(message != NULL);
 
   // The tuple also includes a timestamp, which is ignored.
-  Tuple2<FormData, base::TimeTicks> forms;
+  Tuple<FormData, base::TimeTicks> forms;
   AutofillHostMsg_FormSubmitted::Read(message, &forms);
-  ASSERT_EQ(2U, forms.a.fields.size());
+  ASSERT_EQ(2U, get<0>(forms).fields.size());
 
-  FormFieldData& form_field = forms.a.fields[0];
+  FormFieldData& form_field = get<0>(forms).fields[0];
   EXPECT_EQ(WebString("fname"), form_field.name);
   EXPECT_EQ(WebString("Rick"), form_field.value);
 
-  form_field = forms.a.fields[1];
+  form_field = get<0>(forms).fields[1];
   EXPECT_EQ(WebString("lname"), form_field.name);
   EXPECT_EQ(WebString("Deckard"), form_field.value);
 }
@@ -67,15 +67,15 @@ TEST_F(FormAutocompleteTest, AutoCompleteOffFormSubmit) {
   ASSERT_TRUE(message != NULL);
 
   // The tuple also includes a timestamp, which is ignored.
-  Tuple2<FormData, base::TimeTicks> forms;
+  Tuple<FormData, base::TimeTicks> forms;
   AutofillHostMsg_FormSubmitted::Read(message, &forms);
-  ASSERT_EQ(2U, forms.a.fields.size());
+  ASSERT_EQ(2U, get<0>(forms).fields.size());
 
-  FormFieldData& form_field = forms.a.fields[0];
+  FormFieldData& form_field = get<0>(forms).fields[0];
   EXPECT_EQ(WebString("fname"), form_field.name);
   EXPECT_EQ(WebString("Rick"), form_field.value);
 
-  form_field = forms.a.fields[1];
+  form_field = get<0>(forms).fields[1];
   EXPECT_EQ(WebString("lname"), form_field.name);
   EXPECT_EQ(WebString("Deckard"), form_field.value);
 }
@@ -97,15 +97,15 @@ TEST_F(FormAutocompleteTest, AutoCompleteOffInputSubmit) {
   ASSERT_TRUE(message != NULL);
 
   // The tuple also includes a timestamp, which is ignored.
-  Tuple2<FormData, base::TimeTicks> forms;
+  Tuple<FormData, base::TimeTicks> forms;
   AutofillHostMsg_FormSubmitted::Read(message, &forms);
-  ASSERT_EQ(2U, forms.a.fields.size());
+  ASSERT_EQ(2U, get<0>(forms).fields.size());
 
-  FormFieldData& form_field = forms.a.fields[0];
+  FormFieldData& form_field = get<0>(forms).fields[0];
   EXPECT_EQ(WebString("fname"), form_field.name);
   EXPECT_EQ(WebString("Rick"), form_field.value);
 
-  form_field = forms.a.fields[1];
+  form_field = get<0>(forms).fields[1];
   EXPECT_EQ(WebString("lname"), form_field.name);
   EXPECT_EQ(WebString("Deckard"), form_field.value);
 }
@@ -138,15 +138,15 @@ TEST_F(FormAutocompleteTest, DynamicAutoCompleteOffFormSubmit) {
   ASSERT_TRUE(message != NULL);
 
   // The tuple also includes a timestamp, which is ignored.
-  Tuple2<FormData, base::TimeTicks> forms;
+  Tuple<FormData, base::TimeTicks> forms;
   AutofillHostMsg_FormSubmitted::Read(message, &forms);
-  ASSERT_EQ(2U, forms.a.fields.size());
+  ASSERT_EQ(2U, get<0>(forms).fields.size());
 
-  FormFieldData& form_field = forms.a.fields[0];
+  FormFieldData& form_field = get<0>(forms).fields[0];
   EXPECT_EQ(WebString("fname"), form_field.name);
   EXPECT_EQ(WebString("Rick"), form_field.value);
 
-  form_field = forms.a.fields[1];
+  form_field = get<0>(forms).fields[1];
   EXPECT_EQ(WebString("lname"), form_field.name);
   EXPECT_EQ(WebString("Deckard"), form_field.value);
 }
diff --git a/chrome/renderer/autofill/password_autofill_agent_browsertest.cc b/chrome/renderer/autofill/password_autofill_agent_browsertest.cc
index 31a86f4..2a0e8bb 100644
--- a/chrome/renderer/autofill/password_autofill_agent_browsertest.cc
+++ b/chrome/renderer/autofill/password_autofill_agent_browsertest.cc
@@ -419,12 +419,12 @@ class PasswordAutofillAgentTest : public ChromeRenderViewTest {
         render_thread_->sink().GetFirstMessageMatching(
             AutofillHostMsg_ShowPasswordSuggestions::ID);
     EXPECT_TRUE(message);
-    Tuple5<int, base::i18n::TextDirection, base::string16, int, gfx::RectF>
+    Tuple<int, base::i18n::TextDirection, base::string16, int, gfx::RectF>
         args;
     AutofillHostMsg_ShowPasswordSuggestions::Read(message, &args);
-    EXPECT_EQ(kPasswordFillFormDataId, args.a);
-    EXPECT_EQ(ASCIIToUTF16(username), args.c);
-    EXPECT_EQ(show_all, static_cast<bool>(args.d & autofill::SHOW_ALL));
+    EXPECT_EQ(kPasswordFillFormDataId, get<0>(args));
+    EXPECT_EQ(ASCIIToUTF16(username), get<2>(args));
+    EXPECT_EQ(show_all, static_cast<bool>(get<3>(args) & autofill::SHOW_ALL));
 
     render_thread_->sink().ClearMessages();
   }
@@ -437,11 +437,12 @@ class PasswordAutofillAgentTest : public ChromeRenderViewTest {
         render_thread_->sink().GetFirstMessageMatching(
             AutofillHostMsg_PasswordFormSubmitted::ID);
     ASSERT_TRUE(message);
-    Tuple1<autofill::PasswordForm> args;
+    Tuple<autofill::PasswordForm> args;
     AutofillHostMsg_PasswordFormSubmitted::Read(message, &args);
-    EXPECT_EQ(ASCIIToUTF16(username_value), args.a.username_value);
-    EXPECT_EQ(ASCIIToUTF16(password_value), args.a.password_value);
-    EXPECT_EQ(ASCIIToUTF16(new_password_value), args.a.new_password_value);
+    EXPECT_EQ(ASCIIToUTF16(username_value), get<0>(args).username_value);
+    EXPECT_EQ(ASCIIToUTF16(password_value), get<0>(args).password_value);
+    EXPECT_EQ(ASCIIToUTF16(new_password_value),
+              get<0>(args).new_password_value);
   }
 
   base::string16 username1_;
@@ -805,9 +806,9 @@ TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest) {
   const IPC::Message* message = render_thread_->sink()
       .GetFirstMessageMatching(AutofillHostMsg_PasswordFormsRendered::ID);
   EXPECT_TRUE(message);
-  Tuple2<std::vector<autofill::PasswordForm>, bool > param;
+  Tuple<std::vector<autofill::PasswordForm>, bool> param;
   AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_TRUE(param.a.size());
+  EXPECT_TRUE(get<0>(param).size());
 
   render_thread_->sink().ClearMessages();
   LoadHTML(kEmptyFormHTML);
@@ -815,7 +816,7 @@ TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest) {
       AutofillHostMsg_PasswordFormsRendered::ID);
   EXPECT_TRUE(message);
   AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_FALSE(param.a.size());
+  EXPECT_FALSE(get<0>(param).size());
 
   render_thread_->sink().ClearMessages();
   LoadHTML(kNonVisibleFormHTML);
@@ -823,7 +824,7 @@ TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest) {
       AutofillHostMsg_PasswordFormsRendered::ID);
   EXPECT_TRUE(message);
   AutofillHostMsg_PasswordFormsRendered::Read(message, &param);
-  EXPECT_FALSE(param.a.size());
+  EXPECT_FALSE(get<0>(param).size());
 }
 
 TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest_Redirection) {
diff --git a/chrome/renderer/printing/print_web_view_helper_browsertest.cc b/chrome/renderer/printing/print_web_view_helper_browsertest.cc
index aac87f0..e766fa1 100644
--- a/chrome/renderer/printing/print_web_view_helper_browsertest.cc
+++ b/chrome/renderer/printing/print_web_view_helper_browsertest.cc
@@ -151,7 +151,7 @@ class PrintWebViewHelperTestBase : public ChromeRenderViewTest {
     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)
   }
 
@@ -166,7 +166,7 @@ class PrintWebViewHelperTestBase : public ChromeRenderViewTest {
     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.
@@ -184,7 +184,7 @@ class PrintWebViewHelperTestBase : public ChromeRenderViewTest {
     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)
   }
@@ -494,9 +494,9 @@ class PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase {
     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);
     }
   }
 
@@ -522,12 +522,12 @@ class PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase {
       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;
         }
       }
@@ -547,13 +547,13 @@ class PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase {
       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));
     }
   }
 
diff --git a/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc b/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc
index 5188d39..15c26e3 100644
--- a/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc
+++ b/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc
@@ -23,7 +23,7 @@ void FakeMessageArrival(
   bool handled = provider->OnMessageReceived(
       SpellCheckMsg_RespondTextCheck(
           0,
-          parameters.b,
+          get<1>(parameters),
           fake_result));
   EXPECT_TRUE(handled);
 }
@@ -42,7 +42,7 @@ TEST_F(SpellCheckProviderMacTest, SingleRoundtripSuccess) {
   bool ok = SpellCheckHostMsg_RequestTextCheck::Read(
       provider_.messages_[0], &read_parameters1);
   EXPECT_TRUE(ok);
-  EXPECT_EQ(read_parameters1.c, base::UTF8ToUTF16("hello "));
+  EXPECT_EQ(get<2>(read_parameters1), base::UTF8ToUTF16("hello "));
 
   FakeMessageArrival(&provider_, read_parameters1);
   EXPECT_EQ(completion.completion_count_, 1U);
@@ -68,13 +68,13 @@ TEST_F(SpellCheckProviderMacTest, TwoRoundtripSuccess) {
   bool ok = SpellCheckHostMsg_RequestTextCheck::Read(
       provider_.messages_[0], &read_parameters1);
   EXPECT_TRUE(ok);
-  EXPECT_EQ(read_parameters1.c, base::UTF8ToUTF16("hello "));
+  EXPECT_EQ(get<2>(read_parameters1), base::UTF8ToUTF16("hello "));
 
   SpellCheckHostMsg_RequestTextCheck::Param read_parameters2;
   ok = SpellCheckHostMsg_RequestTextCheck::Read(
       provider_.messages_[1], &read_parameters2);
   EXPECT_TRUE(ok);
-  EXPECT_EQ(read_parameters2.c, base::UTF8ToUTF16("bye "));
+  EXPECT_EQ(get<2>(read_parameters2), base::UTF8ToUTF16("bye "));
 
   FakeMessageArrival(&provider_, read_parameters1);
   EXPECT_EQ(completion1.completion_count_, 1U);
diff --git a/chrome/renderer/translate/translate_helper_browsertest.cc b/chrome/renderer/translate/translate_helper_browsertest.cc
index 8ec52c3..3c0db27 100644
--- a/chrome/renderer/translate/translate_helper_browsertest.cc
+++ b/chrome/renderer/translate/translate_helper_browsertest.cc
@@ -78,15 +78,15 @@ class TranslateHelperBrowserTest : public ChromeRenderViewTest {
         GetUniqueMessageMatching(ChromeViewHostMsg_PageTranslated::ID);
     if (!message)
       return false;
-    Tuple3<std::string, std::string, translate::TranslateErrors::Type>
+    Tuple<std::string, std::string, translate::TranslateErrors::Type>
         translate_param;
     ChromeViewHostMsg_PageTranslated::Read(message, &translate_param);
     if (original_lang)
-      *original_lang = translate_param.a;
+      *original_lang = get<0>(translate_param);
     if (target_lang)
-      *target_lang = translate_param.b;
+      *target_lang = get<1>(translate_param);
     if (error)
-      *error = translate_param.c;
+      *error = get<2>(translate_param);
     return true;
   }
 
@@ -330,7 +330,7 @@ TEST_F(ChromeRenderViewTest, TranslatablePage) {
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Param params;
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_TRUE(params.b) << "Page should be translatable.";
+  EXPECT_TRUE(get<1>(params)) << "Page should be translatable.";
   render_thread_->sink().ClearMessages();
 
   // Now the page specifies the META tag to prevent translation.
@@ -340,7 +340,7 @@ TEST_F(ChromeRenderViewTest, TranslatablePage) {
       ChromeViewHostMsg_TranslateLanguageDetermined::ID);
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_FALSE(params.b) << "Page should not be translatable.";
+  EXPECT_FALSE(get<1>(params)) << "Page should not be translatable.";
   render_thread_->sink().ClearMessages();
 
   // Try the alternate version of the META tag (content instead of value).
@@ -350,7 +350,7 @@ TEST_F(ChromeRenderViewTest, TranslatablePage) {
       ChromeViewHostMsg_TranslateLanguageDetermined::ID);
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_FALSE(params.b) << "Page should not be translatable.";
+  EXPECT_FALSE(get<1>(params)) << "Page should not be translatable.";
 }
 
 // Tests that the language meta tag takes precedence over the CLD when reporting
@@ -367,7 +367,7 @@ TEST_F(ChromeRenderViewTest, LanguageMetaTag) {
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Param params;
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("es", params.a.adopted_language);
+  EXPECT_EQ("es", get<0>(params).adopted_language);
   render_thread_->sink().ClearMessages();
 
   // Makes sure we support multiple languages specified.
@@ -378,7 +378,7 @@ TEST_F(ChromeRenderViewTest, LanguageMetaTag) {
       ChromeViewHostMsg_TranslateLanguageDetermined::ID);
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("fr", params.a.adopted_language);
+  EXPECT_EQ("fr", get<0>(params).adopted_language);
 }
 
 // Tests that the language meta tag works even with non-all-lower-case.
@@ -395,7 +395,7 @@ TEST_F(ChromeRenderViewTest, LanguageMetaTagCase) {
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Param params;
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("es", params.a.adopted_language);
+  EXPECT_EQ("es", get<0>(params).adopted_language);
   render_thread_->sink().ClearMessages();
 
   // Makes sure we support multiple languages specified.
@@ -406,7 +406,7 @@ TEST_F(ChromeRenderViewTest, LanguageMetaTagCase) {
       ChromeViewHostMsg_TranslateLanguageDetermined::ID);
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("fr", params.a.adopted_language);
+  EXPECT_EQ("fr", get<0>(params).adopted_language);
 }
 
 // Tests that the language meta tag is converted to Chrome standard of dashes
@@ -424,7 +424,7 @@ TEST_F(ChromeRenderViewTest, LanguageCommonMistakesAreCorrected) {
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Param params;
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("en", params.a.adopted_language);
+  EXPECT_EQ("en", get<0>(params).adopted_language);
   render_thread_->sink().ClearMessages();
 
   LoadHTML("<html><head><meta http-equiv='Content-Language' content='ZH_tw'>"
@@ -433,7 +433,7 @@ TEST_F(ChromeRenderViewTest, LanguageCommonMistakesAreCorrected) {
       ChromeViewHostMsg_TranslateLanguageDetermined::ID);
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("zh-TW", params.a.adopted_language);
+  EXPECT_EQ("zh-TW", get<0>(params).adopted_language);
   render_thread_->sink().ClearMessages();
 }
 
@@ -447,7 +447,7 @@ TEST_F(ChromeRenderViewTest, BackToTranslatablePage) {
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Param params;
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("zh", params.a.adopted_language);
+  EXPECT_EQ("zh", get<0>(params).adopted_language);
   render_thread_->sink().ClearMessages();
 
   content::PageState back_state = GetCurrentPageState();
@@ -458,7 +458,7 @@ TEST_F(ChromeRenderViewTest, BackToTranslatablePage) {
       ChromeViewHostMsg_TranslateLanguageDetermined::ID);
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("fr", params.a.adopted_language);
+  EXPECT_EQ("fr", get<0>(params).adopted_language);
   render_thread_->sink().ClearMessages();
 
   GoBack(back_state);
@@ -467,6 +467,6 @@ TEST_F(ChromeRenderViewTest, BackToTranslatablePage) {
       ChromeViewHostMsg_TranslateLanguageDetermined::ID);
   ASSERT_NE(static_cast<IPC::Message*>(NULL), message);
   ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, &params);
-  EXPECT_EQ("zh", params.a.adopted_language);
+  EXPECT_EQ("zh", get<0>(params).adopted_language);
   render_thread_->sink().ClearMessages();
 }
diff --git a/chrome/utility/shell_handler_win.h b/chrome/utility/shell_handler_win.h
index fb2441b..fdbed1b 100644
--- a/chrome/utility/shell_handler_win.h
+++ b/chrome/utility/shell_handler_win.h
@@ -19,7 +19,7 @@ namespace base {
 class FilePath;
 }  // namespace base
 
-typedef std::vector<Tuple2<base::string16, base::string16> >
+typedef std::vector<Tuple<base::string16, base::string16>>
     GetOpenFileNameFilter;
 
 struct ChromeUtilityMsg_GetSaveFileName_Params;
diff --git a/components/autofill/content/browser/content_autofill_driver_unittest.cc b/components/autofill/content/browser/content_autofill_driver_unittest.cc
index ffbee12..0ade6e6 100644
--- a/components/autofill/content/browser/content_autofill_driver_unittest.cc
+++ b/components/autofill/content/browser/content_autofill_driver_unittest.cc
@@ -91,13 +91,13 @@ class ContentAutofillDriverTest : public content::RenderViewHostTestHarness {
         process()->sink().GetFirstMessageMatching(kMsgID);
     if (!message)
       return false;
-    Tuple2<int, FormData> autofill_param;
+    Tuple<int, FormData> autofill_param;
     if (!AutofillMsg_FillForm::Read(message, &autofill_param))
       return false;
     if (page_id)
-      *page_id = autofill_param.a;
+      *page_id = get<0>(autofill_param);
     if (results)
-      *results = autofill_param.b;
+      *results = get<1>(autofill_param);
     process()->sink().ClearMessages();
     return true;
   }
@@ -112,13 +112,13 @@ class ContentAutofillDriverTest : public content::RenderViewHostTestHarness {
         process()->sink().GetFirstMessageMatching(kMsgID);
     if (!message)
       return false;
-    Tuple2<int, FormData> autofill_param;
+    Tuple<int, FormData> autofill_param;
     if (!AutofillMsg_PreviewForm::Read(message, &autofill_param))
       return false;
     if (page_id)
-      *page_id = autofill_param.a;
+      *page_id = get<0>(autofill_param);
     if (results)
-      *results = autofill_param.b;
+      *results = get<1>(autofill_param);
     process()->sink().ClearMessages();
     return true;
   }
@@ -135,12 +135,12 @@ class ContentAutofillDriverTest : public content::RenderViewHostTestHarness {
         process()->sink().GetFirstMessageMatching(kMsgID);
     if (!message)
       return false;
-    Tuple1<std::vector<FormDataPredictions> > autofill_param;
+    Tuple<std::vector<FormDataPredictions> > autofill_param;
     if (!AutofillMsg_FieldTypePredictionsAvailable::Read(message,
                                                          &autofill_param))
       return false;
     if (predictions)
-      *predictions = autofill_param.a;
+      *predictions = get<0>(autofill_param);
 
     process()->sink().ClearMessages();
     return true;
@@ -155,7 +155,7 @@ class ContentAutofillDriverTest : public content::RenderViewHostTestHarness {
         process()->sink().GetFirstMessageMatching(messageID);
     if (!message)
       return false;
-    Tuple1<base::string16> autofill_param;
+    Tuple<base::string16> autofill_param;
     switch (messageID) {
       case AutofillMsg_FillFieldWithValue::ID:
         if (!AutofillMsg_FillFieldWithValue::Read(message, &autofill_param))
@@ -174,7 +174,7 @@ class ContentAutofillDriverTest : public content::RenderViewHostTestHarness {
         NOTREACHED();
     }
     if (value)
-      *value = autofill_param.a;
+      *value = get<0>(autofill_param);
     process()->sink().ClearMessages();
     return true;
   }
diff --git a/components/autofill/content/browser/request_autocomplete_manager_unittest.cc b/components/autofill/content/browser/request_autocomplete_manager_unittest.cc
index 193411d..8fe2928 100644
--- a/components/autofill/content/browser/request_autocomplete_manager_unittest.cc
+++ b/components/autofill/content/browser/request_autocomplete_manager_unittest.cc
@@ -122,10 +122,10 @@ class RequestAutocompleteManagerTest :
         process()->sink().GetFirstMessageMatching(kMsgID);
     if (!message)
       return false;
-    Tuple3<blink::WebFormElement::AutocompleteResult, base::string16, FormData>
+    Tuple<blink::WebFormElement::AutocompleteResult, base::string16, FormData>
         autofill_param;
     AutofillMsg_RequestAutocompleteResult::Read(message, &autofill_param);
-    *result = autofill_param.a;
+    *result = get<0>(autofill_param);
     process()->sink().ClearMessages();
     return true;
   }
diff --git a/components/autofill/content/renderer/renderer_save_password_progress_logger_unittest.cc b/components/autofill/content/renderer/renderer_save_password_progress_logger_unittest.cc
index f46df5b..4b0d116 100644
--- a/components/autofill/content/renderer/renderer_save_password_progress_logger_unittest.cc
+++ b/components/autofill/content/renderer/renderer_save_password_progress_logger_unittest.cc
@@ -30,9 +30,9 @@ class TestLogger : public RendererSavePasswordProgressLogger {
     const IPC::Message* message = sink_.GetFirstMessageMatching(kMsgID);
     if (!message)
       return false;
-    Tuple1<std::string> param;
+    Tuple<std::string> param;
     AutofillHostMsg_RecordSavePasswordProgress::Read(message, &param);
-    *log = param.a;
+    *log = get<0>(param);
     sink_.ClearMessages();
     return true;
   }
diff --git a/components/password_manager/content/browser/content_credential_manager_dispatcher_unittest.cc b/components/password_manager/content/browser/content_credential_manager_dispatcher_unittest.cc
index 9d64b9e..0b782e7 100644
--- a/components/password_manager/content/browser/content_credential_manager_dispatcher_unittest.cc
+++ b/components/password_manager/content/browser/content_credential_manager_dispatcher_unittest.cc
@@ -234,7 +234,7 @@ TEST_F(ContentCredentialManagerDispatcherTest,
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
-  EXPECT_EQ(CREDENTIAL_TYPE_EMPTY, param.b.type);
+  EXPECT_EQ(CREDENTIAL_TYPE_EMPTY, get<1>(param).type);
   process()->sink().ClearMessages();
   EXPECT_FALSE(client_->did_prompt_user_to_choose());
 }
@@ -254,7 +254,7 @@ TEST_F(ContentCredentialManagerDispatcherTest,
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
-  EXPECT_EQ(CREDENTIAL_TYPE_EMPTY, param.b.type);
+  EXPECT_EQ(CREDENTIAL_TYPE_EMPTY, get<1>(param).type);
   process()->sink().ClearMessages();
   EXPECT_FALSE(client_->did_prompt_user_to_choose());
 }
@@ -291,7 +291,7 @@ TEST_F(ContentCredentialManagerDispatcherTest,
   CredentialManagerMsg_RejectCredentialRequest::Param reject_param;
   CredentialManagerMsg_RejectCredentialRequest::Read(message, &reject_param);
   EXPECT_EQ(blink::WebCredentialManagerError::ErrorTypePendingRequest,
-            reject_param.b);
+            get<1>(reject_param));
   EXPECT_FALSE(client_->did_prompt_user_to_choose());
 
   process()->sink().ClearMessages();
@@ -305,8 +305,7 @@ TEST_F(ContentCredentialManagerDispatcherTest,
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
-  CredentialManagerMsg_SendCredential::Read(message, &send_param);
-  EXPECT_NE(CREDENTIAL_TYPE_EMPTY, send_param.b.type);
+  EXPECT_NE(CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type);
   process()->sink().ClearMessages();
   EXPECT_TRUE(client_->did_prompt_user_to_choose());
 }
diff --git a/components/password_manager/content/renderer/credential_manager_client_browsertest.cc b/components/password_manager/content/renderer/credential_manager_client_browsertest.cc
index 4d4de67..c86d065 100644
--- a/components/password_manager/content/renderer/credential_manager_client_browsertest.cc
+++ b/components/password_manager/content/renderer/credential_manager_client_browsertest.cc
@@ -52,30 +52,30 @@ class CredentialManagerClientTest : public content::RenderViewTest {
 
     switch (message_id) {
       case CredentialManagerHostMsg_NotifyFailedSignIn::ID: {
-        Tuple2<int, CredentialInfo> param;
+        Tuple<int, CredentialInfo> param;
         CredentialManagerHostMsg_NotifyFailedSignIn::Read(message, &param);
-        request_id = param.a;
+        request_id = get<0>(param);
         break;
       }
 
       case CredentialManagerHostMsg_NotifySignedIn::ID: {
-        Tuple2<int, CredentialInfo> param;
+        Tuple<int, CredentialInfo> param;
         CredentialManagerHostMsg_NotifySignedIn::Read(message, &param);
-        request_id = param.a;
+        request_id = get<0>(param);
         break;
       }
 
       case CredentialManagerHostMsg_NotifySignedOut::ID: {
-        Tuple1<int> param;
+        Tuple<int> param;
         CredentialManagerHostMsg_NotifySignedOut::Read(message, &param);
-        request_id = param.a;
+        request_id = get<0>(param);
         break;
       }
 
       case CredentialManagerHostMsg_RequestCredential::ID: {
-        Tuple3<int, bool, std::vector<GURL> > param;
+        Tuple<int, bool, std::vector<GURL> > param;
         CredentialManagerHostMsg_RequestCredential::Read(message, &param);
-        request_id = param.a;
+        request_id = get<0>(param);
         break;
       }
 
diff --git a/content/browser/devtools/render_view_devtools_agent_host.cc b/content/browser/devtools/render_view_devtools_agent_host.cc
index ebb0aef..d80e10f 100644
--- a/content/browser/devtools/render_view_devtools_agent_host.cc
+++ b/content/browser/devtools/render_view_devtools_agent_host.cc
@@ -480,7 +480,7 @@ void RenderViewDevToolsAgentHost::OnSwapCompositorFrame(
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return;
-  page_handler_->OnSwapCompositorFrame(param.b.metadata);
+  page_handler_->OnSwapCompositorFrame(get<1>(param).metadata);
 }
 
 void RenderViewDevToolsAgentHost::SynchronousSwapCompositorFrame(
diff --git a/content/browser/frame_host/navigation_controller_impl_unittest.cc b/content/browser/frame_host/navigation_controller_impl_unittest.cc
index 48b52c9..eb159be 100644
--- a/content/browser/frame_host/navigation_controller_impl_unittest.cc
+++ b/content/browser/frame_host/navigation_controller_impl_unittest.cc
@@ -225,13 +225,13 @@ class NavigationControllerTest
   const GURL GetNavigationURLFromIPC(const IPC::Message* message) {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableBrowserSideNavigation)) {
-      Tuple2<CommonNavigationParams, RequestNavigationParams> nav_params;
+      Tuple<CommonNavigationParams, RequestNavigationParams> nav_params;
       FrameMsg_RequestNavigation::Read(message, &nav_params);
-      return nav_params.a.url;
+      return get<0>(nav_params).url;
     }
-    Tuple1<FrameMsg_Navigate_Params> nav_params;
+    Tuple<FrameMsg_Navigate_Params> nav_params;
     FrameMsg_Navigate::Read(message, &nav_params);
-    return nav_params.a.common_params.url;
+    return get<0>(nav_params).common_params.url;
   }
 
  protected:
diff --git a/content/browser/renderer_host/input/input_router_impl_unittest.cc b/content/browser/renderer_host/input/input_router_impl_unittest.cc
index 08562d3..c8816ff 100644
--- a/content/browser/renderer_host/input/input_router_impl_unittest.cc
+++ b/content/browser/renderer_host/input/input_router_impl_unittest.cc
@@ -80,7 +80,7 @@ WebInputEvent& GetEventWithType(WebInputEvent::Type type) {
 bool GetIsShortcutFromHandleInputEventMessage(const IPC::Message* msg) {
   InputMsg_HandleInputEvent::Schema::Param param;
   InputMsg_HandleInputEvent::Read(msg, &param);
-  return param.c;
+  return get<2>(param);
 }
 
 template<typename MSG_T, typename ARG_T1>
@@ -88,7 +88,7 @@ void ExpectIPCMessageWithArg1(const IPC::Message* msg, const ARG_T1& arg1) {
   ASSERT_EQ(MSG_T::ID, msg->type());
   typename MSG_T::Schema::Param param;
   ASSERT_TRUE(MSG_T::Read(msg, &param));
-  EXPECT_EQ(arg1, param.a);
+  EXPECT_EQ(arg1, get<0>(param));
 }
 
 template<typename MSG_T, typename ARG_T1, typename ARG_T2>
@@ -98,8 +98,8 @@ void ExpectIPCMessageWithArg2(const IPC::Message* msg,
   ASSERT_EQ(MSG_T::ID, msg->type());
   typename MSG_T::Schema::Param param;
   ASSERT_TRUE(MSG_T::Read(msg, &param));
-  EXPECT_EQ(arg1, param.a);
-  EXPECT_EQ(arg2, param.b);
+  EXPECT_EQ(arg1, get<0>(param));
+  EXPECT_EQ(arg2, get<1>(param));
 }
 
 #if defined(USE_AURA)
diff --git a/content/browser/renderer_host/input/touch_input_browsertest.cc b/content/browser/renderer_host/input/touch_input_browsertest.cc
index 3a9f2fd..d303271 100644
--- a/content/browser/renderer_host/input/touch_input_browsertest.cc
+++ b/content/browser/renderer_host/input/touch_input_browsertest.cc
@@ -112,8 +112,8 @@ class InputEventMessageFilter : public BrowserMessageFilter {
     if (message.type() == InputHostMsg_HandleInputEvent_ACK::ID) {
       InputHostMsg_HandleInputEvent_ACK::Param params;
       InputHostMsg_HandleInputEvent_ACK::Read(&message, &params);
-      WebInputEvent::Type type = params.a.type;
-      InputEventAckState ack = params.a.state;
+      WebInputEvent::Type type = get<0>(params).type;
+      InputEventAckState ack = get<0>(params).state;
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::Bind(&InputEventMessageFilter::ReceivedEventAck,
                      this, type, ack));
diff --git a/content/browser/renderer_host/media/webrtc_identity_service_host_unittest.cc b/content/browser/renderer_host/media/webrtc_identity_service_host_unittest.cc
index 4a9c5d2..c420942 100644
--- a/content/browser/renderer_host/media/webrtc_identity_service_host_unittest.cc
+++ b/content/browser/renderer_host/media/webrtc_identity_service_host_unittest.cc
@@ -116,10 +116,10 @@ class WebRTCIdentityServiceHostTest : public ::testing::Test {
     IPC::Message ipc = host_->GetLastMessage();
     EXPECT_EQ(ipc.type(), WebRTCIdentityHostMsg_RequestFailed::ID);
 
-    Tuple2<int, int> error_in_message;
+    Tuple<int, int> error_in_message;
     WebRTCIdentityHostMsg_RequestFailed::Read(&ipc, &error_in_message);
-    EXPECT_EQ(FAKE_SEQUENCE_NUMBER, error_in_message.a);
-    EXPECT_EQ(error, error_in_message.b);
+    EXPECT_EQ(FAKE_SEQUENCE_NUMBER, get<0>(error_in_message));
+    EXPECT_EQ(error, get<1>(error_in_message));
   }
 
   void VerifyIdentityReadyMessage(const std::string& cert,
@@ -128,11 +128,11 @@ class WebRTCIdentityServiceHostTest : public ::testing::Test {
     IPC::Message ipc = host_->GetLastMessage();
     EXPECT_EQ(ipc.type(), WebRTCIdentityHostMsg_IdentityReady::ID);
 
-    Tuple3<int, std::string, std::string> identity_in_message;
+    Tuple<int, std::string, std::string> identity_in_message;
     WebRTCIdentityHostMsg_IdentityReady::Read(&ipc, &identity_in_message);
-    EXPECT_EQ(FAKE_SEQUENCE_NUMBER, identity_in_message.a);
-    EXPECT_EQ(cert, identity_in_message.b);
-    EXPECT_EQ(key, identity_in_message.c);
+    EXPECT_EQ(FAKE_SEQUENCE_NUMBER, get<0>(identity_in_message));
+    EXPECT_EQ(cert, get<1>(identity_in_message));
+    EXPECT_EQ(key, get<2>(identity_in_message));
   }
 
  protected:
diff --git a/content/browser/renderer_host/p2p/socket_host_test_utils.h b/content/browser/renderer_host/p2p/socket_host_test_utils.h
index b94a2ee..b008f9f 100644
--- a/content/browser/renderer_host/p2p/socket_host_test_utils.h
+++ b/content/browser/renderer_host/p2p/socket_host_test_utils.h
@@ -102,7 +102,7 @@ MATCHER_P(MatchPacketMessage, packet_content, "") {
     return false;
   P2PMsg_OnDataReceived::Param params;
   P2PMsg_OnDataReceived::Read(arg, &params);
-  return params.c == packet_content;
+  return get<2>(params) == packet_content;
 }
 
 MATCHER_P(MatchIncomingSocketMessage, address, "") {
@@ -111,7 +111,7 @@ MATCHER_P(MatchIncomingSocketMessage, address, "") {
   P2PMsg_OnIncomingTcpConnection::Param params;
   P2PMsg_OnIncomingTcpConnection::Read(
       arg, &params);
-  return params.b == address;
+  return get<1>(params) == address;
 }
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_P2P_SOCKET_HOST_TEST_UTILS_H_
diff --git a/content/browser/renderer_host/pepper/pepper_printing_host_unittest.cc b/content/browser/renderer_host/pepper/pepper_printing_host_unittest.cc
index 36b006c..de06ef3 100644
--- a/content/browser/renderer_host/pepper/pepper_printing_host_unittest.cc
+++ b/content/browser/renderer_host/pepper/pepper_printing_host_unittest.cc
@@ -105,7 +105,7 @@ TEST_F(PepperPrintingHostTest, GetDefaultPrintSettings) {
       reply_msg_param;
   ASSERT_TRUE(PpapiPluginMsg_Printing_GetDefaultPrintSettingsReply::Read(
       &reply_msg, &reply_msg_param));
-  PP_PrintSettings_Dev actual_settings = reply_msg_param.a;
+  PP_PrintSettings_Dev actual_settings = get<0>(reply_msg_param);
 
   EXPECT_TRUE(PP_RectEqual(expected_settings.printable_area,
                            actual_settings.printable_area));
diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index 986bda4..4cf0f14 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc
@@ -1428,10 +1428,10 @@ bool RenderWidgetHostImpl::OnSwapCompositorFrame(
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return false;
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
-  uint32 output_surface_id = param.a;
-  param.b.AssignTo(frame.get());
+  uint32 output_surface_id = get<0>(param);
+  get<1>(param).AssignTo(frame.get());
   std::vector<IPC::Message> messages_to_deliver_with_frame;
-  messages_to_deliver_with_frame.swap(param.c);
+  messages_to_deliver_with_frame.swap(get<2>(param));
 
   latency_tracker_.OnSwapCompositorFrame(&frame->metadata.latency_info);
 
diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc
index 2e3ba90..799a835 100644
--- a/content/browser/renderer_host/render_widget_host_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_unittest.cc
@@ -780,9 +780,9 @@ TEST_F(RenderWidgetHostTest, Background) {
       process_->sink().GetUniqueMessageMatching(
           ViewMsg_SetBackgroundOpaque::ID);
   ASSERT_TRUE(set_background);
-  Tuple1<bool> sent_background;
+  Tuple<bool> sent_background;
   ViewMsg_SetBackgroundOpaque::Read(set_background, &sent_background);
-  EXPECT_FALSE(sent_background.a);
+  EXPECT_FALSE(get<0>(sent_background));
 
 #if defined(USE_AURA)
   // See the comment above |InitAsChild(NULL)|.
@@ -817,9 +817,9 @@ TEST_F(RenderWidgetHostTest, HiddenPaint) {
   const IPC::Message* restored = process_->sink().GetUniqueMessageMatching(
       ViewMsg_WasShown::ID);
   ASSERT_TRUE(restored);
-  Tuple2<bool, ui::LatencyInfo> needs_repaint;
+  Tuple<bool, ui::LatencyInfo> needs_repaint;
   ViewMsg_WasShown::Read(restored, &needs_repaint);
-  EXPECT_TRUE(needs_repaint.a);
+  EXPECT_TRUE(get<0>(needs_repaint));
 }
 
 TEST_F(RenderWidgetHostTest, IgnoreKeyEventsHandledByRenderer) {
@@ -1021,7 +1021,7 @@ std::string GetInputMessageTypes(RenderWidgetHostProcess* process) {
     EXPECT_EQ(InputMsg_HandleInputEvent::ID, message->type());
     InputMsg_HandleInputEvent::Param params;
     EXPECT_TRUE(InputMsg_HandleInputEvent::Read(message, &params));
-    const WebInputEvent* event = params.a;
+    const WebInputEvent* event = get<0>(params);
     if (i != 0)
       result += " ";
     result += WebInputEventTraits::GetName(event->type);
@@ -1343,7 +1343,7 @@ ui::LatencyInfo GetLatencyInfoFromInputEvent(RenderWidgetHostProcess* process) {
   InputMsg_HandleInputEvent::Param params;
   EXPECT_TRUE(InputMsg_HandleInputEvent::Read(message, &params));
   process->sink().ClearMessages();
-  return params.b;
+  return get<1>(params);
 }
 
 void CheckLatencyInfoComponentInMessage(RenderWidgetHostProcess* process,
diff --git a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
index 6d840d7..13d986b 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
@@ -658,10 +658,10 @@ class RenderWidgetHostViewAuraOverscrollTest
       return;
     }
 
-    if (WebInputEventTraits::IgnoresAckDisposition(*params.a))
+    if (WebInputEventTraits::IgnoresAckDisposition(*get<0>(params)))
       return;
 
-    SendInputEventACK(params.a->type, ack_result);
+    SendInputEventACK(get<0>(params)->type, ack_result);
   }
 
   SyntheticWebTouchEvent touch_event_;
@@ -903,19 +903,20 @@ TEST_F(RenderWidgetHostViewAuraTest, SetCompositionText) {
     InputMsg_ImeSetComposition::Param params;
     InputMsg_ImeSetComposition::Read(msg, &params);
     // composition text
-    EXPECT_EQ(composition_text.text, params.a);
+    EXPECT_EQ(composition_text.text, get<0>(params));
     // underlines
-    ASSERT_EQ(underlines.size(), params.b.size());
+    ASSERT_EQ(underlines.size(), get<1>(params).size());
     for (size_t i = 0; i < underlines.size(); ++i) {
-      EXPECT_EQ(underlines[i].start_offset, params.b[i].startOffset);
-      EXPECT_EQ(underlines[i].end_offset, params.b[i].endOffset);
-      EXPECT_EQ(underlines[i].color, params.b[i].color);
-      EXPECT_EQ(underlines[i].thick, params.b[i].thick);
-      EXPECT_EQ(underlines[i].background_color, params.b[i].backgroundColor);
+      EXPECT_EQ(underlines[i].start_offset, get<1>(params)[i].startOffset);
+      EXPECT_EQ(underlines[i].end_offset, get<1>(params)[i].endOffset);
+      EXPECT_EQ(underlines[i].color, get<1>(params)[i].color);
+      EXPECT_EQ(underlines[i].thick, get<1>(params)[i].thick);
+      EXPECT_EQ(underlines[i].background_color,
+                get<1>(params)[i].backgroundColor);
     }
     // highlighted range
-    EXPECT_EQ(4, params.c) << "Should be the same to the caret pos";
-    EXPECT_EQ(4, params.d) << "Should be the same to the caret pos";
+    EXPECT_EQ(4, get<2>(params)) << "Should be the same to the caret pos";
+    EXPECT_EQ(4, get<3>(params)) << "Should be the same to the caret pos";
   }
 
   view_->ImeCancelComposition();
@@ -1139,9 +1140,9 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) {
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
-    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
+    EXPECT_EQ("100x100", get<0>(params).new_size.ToString());  // dip size
     EXPECT_EQ("100x100",
-        params.a.physical_backing_size.ToString());  // backing size
+        get<0>(params).physical_backing_size.ToString());  // backing size
   }
 
   widget_host_->ResetSizeAndRepaintPendingFlags();
@@ -1156,10 +1157,10 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) {
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
-    EXPECT_EQ(2.0f, params.a.screen_info.deviceScaleFactor);
-    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
+    EXPECT_EQ(2.0f, get<0>(params).screen_info.deviceScaleFactor);
+    EXPECT_EQ("100x100", get<0>(params).new_size.ToString());  // dip size
     EXPECT_EQ("200x200",
-        params.a.physical_backing_size.ToString());  // backing size
+        get<0>(params).physical_backing_size.ToString());  // backing size
   }
 
   widget_host_->ResetSizeAndRepaintPendingFlags();
@@ -1174,10 +1175,10 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) {
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
-    EXPECT_EQ(1.0f, params.a.screen_info.deviceScaleFactor);
-    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
+    EXPECT_EQ(1.0f, get<0>(params).screen_info.deviceScaleFactor);
+    EXPECT_EQ("100x100", get<0>(params).new_size.ToString());  // dip size
     EXPECT_EQ("100x100",
-        params.a.physical_backing_size.ToString());  // backing size
+        get<0>(params).physical_backing_size.ToString());  // backing size
   }
 }
 
@@ -1342,14 +1343,14 @@ TEST_F(RenderWidgetHostViewAuraTest, DISABLED_FullscreenResize) {
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
     EXPECT_EQ("0,0 800x600",
-              gfx::Rect(params.a.screen_info.availableRect).ToString());
-    EXPECT_EQ("800x600", params.a.new_size.ToString());
+              gfx::Rect(get<0>(params).screen_info.availableRect).ToString());
+    EXPECT_EQ("800x600", 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, params.a.new_size, gfx::Rect(params.a.new_size)));
+            1.f, get<0>(params).new_size, gfx::Rect(get<0>(params).new_size)));
     ui::DrawWaiterForTest::WaitForCommit(
         root_window->GetHost()->compositor());
   }
@@ -1367,12 +1368,12 @@ TEST_F(RenderWidgetHostViewAuraTest, DISABLED_FullscreenResize) {
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
     EXPECT_EQ("0,0 1600x1200",
-              gfx::Rect(params.a.screen_info.availableRect).ToString());
-    EXPECT_EQ("1600x1200", params.a.new_size.ToString());
+              gfx::Rect(get<0>(params).screen_info.availableRect).ToString());
+    EXPECT_EQ("1600x1200", get<0>(params).new_size.ToString());
     view_->OnSwapCompositorFrame(
         0,
         MakeDelegatedFrame(
-            1.f, params.a.new_size, gfx::Rect(params.a.new_size)));
+            1.f, get<0>(params).new_size, gfx::Rect(get<0>(params).new_size)));
     ui::DrawWaiterForTest::WaitForCommit(
         root_window->GetHost()->compositor());
   }
@@ -1471,7 +1472,7 @@ TEST_F(RenderWidgetHostViewAuraTest, Resize) {
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
-    EXPECT_EQ(size2.ToString(), params.a.new_size.ToString());
+    EXPECT_EQ(size2.ToString(), get<0>(params).new_size.ToString());
   }
   // Send resize ack to observe new Resize messages.
   update_params.view_size = size2;
@@ -1522,7 +1523,7 @@ TEST_F(RenderWidgetHostViewAuraTest, Resize) {
     EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
     ViewMsg_Resize::Param params;
     ViewMsg_Resize::Read(msg, &params);
-    EXPECT_EQ(size3.ToString(), params.a.new_size.ToString());
+    EXPECT_EQ(size3.ToString(), get<0>(params).new_size.ToString());
   }
   update_params.view_size = size3;
   widget_host_->OnMessageReceived(
@@ -2096,7 +2097,7 @@ TEST_F(RenderWidgetHostViewAuraTest, VisibleViewportTest) {
 
   ViewMsg_Resize::Param params;
   ViewMsg_Resize::Read(message, &params);
-  EXPECT_EQ(60, params.a.visible_viewport_size.height());
+  EXPECT_EQ(60, get<0>(params).visible_viewport_size.height());
 }
 
 // Ensures that touch event positions are never truncated to integers.
diff --git a/content/browser/resolve_proxy_msg_helper_unittest.cc b/content/browser/resolve_proxy_msg_helper_unittest.cc
index 1a19018..7499a15 100644
--- a/content/browser/resolve_proxy_msg_helper_unittest.cc
+++ b/content/browser/resolve_proxy_msg_helper_unittest.cc
@@ -90,7 +90,8 @@ class ResolveProxyMsgHelperTest : public testing::Test, public IPC::Listener {
     TupleTypes<ViewHostMsg_ResolveProxy::ReplyParam>::ValueTuple reply_data;
     EXPECT_TRUE(ViewHostMsg_ResolveProxy::ReadReplyParam(&msg, &reply_data));
     DCHECK(!pending_result_.get());
-    pending_result_.reset(new PendingResult(reply_data.a, reply_data.b));
+    pending_result_.reset(
+        new PendingResult(get<0>(reply_data), get<1>(reply_data)));
     test_sink_.ClearMessages();
     return true;
   }
diff --git a/content/browser/service_worker/service_worker_handle_unittest.cc b/content/browser/service_worker/service_worker_handle_unittest.cc
index 2a4d286..75ea7d1 100644
--- a/content/browser/service_worker/service_worker_handle_unittest.cc
+++ b/content/browser/service_worker/service_worker_handle_unittest.cc
@@ -32,8 +32,8 @@ void VerifyStateChangedMessage(int expected_handle_id,
   ServiceWorkerMsg_ServiceWorkerStateChanged::Param param;
   ASSERT_TRUE(ServiceWorkerMsg_ServiceWorkerStateChanged::Read(
       message, &param));
-  EXPECT_EQ(expected_handle_id, param.b);
-  EXPECT_EQ(expected_state, param.c);
+  EXPECT_EQ(expected_handle_id, get<1>(param));
+  EXPECT_EQ(expected_state, get<2>(param));
 }
 
 }  // namespace
diff --git a/content/browser/shared_worker/shared_worker_host.cc b/content/browser/shared_worker/shared_worker_host.cc
index 2b66849..8500a79 100644
--- a/content/browser/shared_worker/shared_worker_host.cc
+++ b/content/browser/shared_worker/shared_worker_host.cc
@@ -267,8 +267,8 @@ void SharedWorkerHost::RelayMessage(
     WorkerMsg_Connect::Param param;
     if (!WorkerMsg_Connect::Read(&message, &param))
       return;
-    int sent_message_port_id = param.a;
-    int new_routing_id = param.b;
+    int sent_message_port_id = get<0>(param);
+    int new_routing_id = get<1>(param);
 
     DCHECK(container_render_filter_);
     new_routing_id = container_render_filter_->GetNextRoutingID();
diff --git a/content/browser/shared_worker/shared_worker_service_impl_unittest.cc b/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
index 8e1dd80..bdcc3eb 100644
--- a/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
+++ b/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
@@ -326,12 +326,12 @@ void CheckWorkerProcessMsgCreateWorker(
     int* route_id) {
   scoped_ptr<IPC::Message> msg(renderer_host->PopMessage());
   EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type());
-  Tuple1<WorkerProcessMsg_CreateWorker_Params> param;
+  Tuple<WorkerProcessMsg_CreateWorker_Params> param;
   EXPECT_TRUE(WorkerProcessMsg_CreateWorker::Read(msg.get(), &param));
-  EXPECT_EQ(GURL(expected_url), param.a.url);
-  EXPECT_EQ(base::ASCIIToUTF16(expected_name), param.a.name);
-  EXPECT_EQ(expected_security_policy_type, param.a.security_policy_type);
-  *route_id = param.a.route_id;
+  EXPECT_EQ(GURL(expected_url), get<0>(param).url);
+  EXPECT_EQ(base::ASCIIToUTF16(expected_name), get<0>(param).name);
+  EXPECT_EQ(expected_security_policy_type, get<0>(param).security_policy_type);
+  *route_id = get<0>(param).route_id;
 }
 
 void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host,
@@ -357,8 +357,8 @@ void CheckWorkerMsgConnect(MockRendererProcessHost* renderer_host,
   EXPECT_EQ(expected_msg_route_id, msg->routing_id());
   WorkerMsg_Connect::Param params;
   EXPECT_TRUE(WorkerMsg_Connect::Read(msg.get(), &params));
-  int port_id = params.a;
-  *routing_id = params.b;
+  int port_id = get<0>(params);
+  *routing_id = get<1>(params);
   EXPECT_EQ(expected_sent_message_port_id, port_id);
 }
 
@@ -370,7 +370,7 @@ void CheckMessagePortMsgMessage(MockRendererProcessHost* renderer_host,
   EXPECT_EQ(expected_msg_route_id, msg->routing_id());
   MessagePortMsg_Message::Param params;
   EXPECT_TRUE(MessagePortMsg_Message::Read(msg.get(), &params));
-  base::string16 data = params.a;
+  base::string16 data = get<0>(params);
   EXPECT_EQ(base::ASCIIToUTF16(expected_data), data);
 }
 
diff --git a/content/browser/web_contents/web_contents_view_aura_browsertest.cc b/content/browser/web_contents/web_contents_view_aura_browsertest.cc
index 81f4cd9..af58c88 100644
--- a/content/browser/web_contents/web_contents_view_aura_browsertest.cc
+++ b/content/browser/web_contents/web_contents_view_aura_browsertest.cc
@@ -214,8 +214,8 @@ class InputEventMessageFilterWaitsForAcks : public BrowserMessageFilter {
     if (message.type() == InputHostMsg_HandleInputEvent_ACK::ID) {
       InputHostMsg_HandleInputEvent_ACK::Param params;
       InputHostMsg_HandleInputEvent_ACK::Read(&message, &params);
-      blink::WebInputEvent::Type type = params.a.type;
-      InputEventAckState ack = params.a.state;
+      blink::WebInputEvent::Type type = get<0>(params).type;
+      InputEventAckState ack = get<0>(params).state;
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::Bind(&InputEventMessageFilterWaitsForAcks::ReceivedEventAck,
                      this, type, ack));
diff --git a/content/child/resource_dispatcher_unittest.cc b/content/child/resource_dispatcher_unittest.cc
index 4324640..46ce695 100644
--- a/content/child/resource_dispatcher_unittest.cc
+++ b/content/child/resource_dispatcher_unittest.cc
@@ -183,60 +183,60 @@ class ResourceDispatcherTest : public testing::Test, public IPC::Sender {
       ADD_FAILURE() << "Expected ResourceHostMsg_RequestResource message";
       return -1;
     }
-    ResourceHostMsg_Request request = params.c;
+    ResourceHostMsg_Request request = get<2>(params);
     EXPECT_EQ(kTestPageUrl, request.url.spec());
     message_queue_.erase(message_queue_.begin());
-    return params.b;
+    return get<1>(params);
   }
 
   void ConsumeFollowRedirect(int expected_request_id) {
     ASSERT_FALSE(message_queue_.empty());
-    Tuple1<int> args;
+    Tuple<int> args;
     ASSERT_EQ(ResourceHostMsg_FollowRedirect::ID, message_queue_[0].type());
     ASSERT_TRUE(ResourceHostMsg_FollowRedirect::Read(
         &message_queue_[0], &args));
-    EXPECT_EQ(expected_request_id, args.a);
+    EXPECT_EQ(expected_request_id, get<0>(args));
     message_queue_.erase(message_queue_.begin());
   }
 
   void ConsumeDataReceived_ACK(int expected_request_id) {
     ASSERT_FALSE(message_queue_.empty());
-    Tuple1<int> args;
+    Tuple<int> args;
     ASSERT_EQ(ResourceHostMsg_DataReceived_ACK::ID, message_queue_[0].type());
     ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read(
         &message_queue_[0], &args));
-    EXPECT_EQ(expected_request_id, args.a);
+    EXPECT_EQ(expected_request_id, get<0>(args));
     message_queue_.erase(message_queue_.begin());
   }
 
   void ConsumeDataDownloaded_ACK(int expected_request_id) {
     ASSERT_FALSE(message_queue_.empty());
-    Tuple1<int> args;
+    Tuple<int> args;
     ASSERT_EQ(ResourceHostMsg_DataDownloaded_ACK::ID, message_queue_[0].type());
     ASSERT_TRUE(ResourceHostMsg_DataDownloaded_ACK::Read(
         &message_queue_[0], &args));
-    EXPECT_EQ(expected_request_id, args.a);
+    EXPECT_EQ(expected_request_id, get<0>(args));
     message_queue_.erase(message_queue_.begin());
   }
 
   void ConsumeReleaseDownloadedFile(int expected_request_id) {
     ASSERT_FALSE(message_queue_.empty());
-    Tuple1<int> args;
+    Tuple<int> args;
     ASSERT_EQ(ResourceHostMsg_ReleaseDownloadedFile::ID,
               message_queue_[0].type());
     ASSERT_TRUE(ResourceHostMsg_ReleaseDownloadedFile::Read(
         &message_queue_[0], &args));
-    EXPECT_EQ(expected_request_id, args.a);
+    EXPECT_EQ(expected_request_id, get<0>(args));
     message_queue_.erase(message_queue_.begin());
   }
 
   void ConsumeCancelRequest(int expected_request_id) {
     ASSERT_FALSE(message_queue_.empty());
-    Tuple1<int> args;
+    Tuple<int> args;
     ASSERT_EQ(ResourceHostMsg_CancelRequest::ID, message_queue_[0].type());
     ASSERT_TRUE(ResourceHostMsg_CancelRequest::Read(
         &message_queue_[0], &args));
-    EXPECT_EQ(expected_request_id, args.a);
+    EXPECT_EQ(expected_request_id, get<0>(args));
     message_queue_.erase(message_queue_.begin());
   }
 
diff --git a/content/child/threaded_data_provider.cc b/content/child/threaded_data_provider.cc
index adf52cd..5d93a19 100644
--- a/content/child/threaded_data_provider.cc
+++ b/content/child/threaded_data_provider.cc
@@ -95,7 +95,7 @@ bool DataProviderMessageFilter::OnMessageReceived(
   if (request_id == request_id_) {
     ResourceMsg_DataReceived::Schema::Param arg;
     if (ResourceMsg_DataReceived::Read(&message, &arg)) {
-      OnReceivedData(arg.a, arg.b, arg.c, arg.d);
+      OnReceivedData(get<0>(arg), get<1>(arg), get<2>(arg), get<3>(arg));
       return true;
     }
   }
diff --git a/content/common/gpu/gpu_channel.cc b/content/common/gpu/gpu_channel.cc
index b3e2fac..e60586c 100644
--- a/content/common/gpu/gpu_channel.cc
+++ b/content/common/gpu/gpu_channel.cc
@@ -111,7 +111,7 @@ class GpuChannelMessageFilter : public IPC::MessageFilter {
     }
 
     if (message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) {
-      Tuple1<bool> retire;
+      Tuple<bool> retire;
       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
       if (!GpuCommandBufferMsg_InsertSyncPoint::ReadSendParam(&message,
                                                               &retire)) {
@@ -119,7 +119,7 @@ class GpuChannelMessageFilter : public IPC::MessageFilter {
         Send(reply);
         return true;
       }
-      if (!future_sync_points_ && !retire.a) {
+      if (!future_sync_points_ && !get<0>(retire)) {
         LOG(ERROR) << "Untrusted contexts can't create future sync points";
         reply->set_reply_error();
         Send(reply);
@@ -134,7 +134,7 @@ class GpuChannelMessageFilter : public IPC::MessageFilter {
                      gpu_channel_,
                      sync_point_manager_,
                      message.routing_id(),
-                     retire.a,
+                     get<0>(retire),
                      sync_point));
       handled = true;
     }
diff --git a/content/common/gpu/media/android_video_encode_accelerator.cc b/content/common/gpu/media/android_video_encode_accelerator.cc
index 340d5ae..0fe13f5 100644
--- a/content/common/gpu/media/android_video_encode_accelerator.cc
+++ b/content/common/gpu/media/android_video_encode_accelerator.cc
@@ -320,7 +320,7 @@ void AndroidVideoEncodeAccelerator::QueueInput() {
   }
 
   const PendingFrames::value_type& input = pending_frames_.front();
-  bool is_key_frame = input.b;
+  bool is_key_frame = get<1>(input);
   if (is_key_frame) {
     // Ideally MediaCodec would honor BUFFER_FLAG_SYNC_FRAME so we could
     // indicate this in the QueueInputBuffer() call below and guarantee _this_
@@ -328,7 +328,7 @@ void AndroidVideoEncodeAccelerator::QueueInput() {
     // Instead, we request a key frame "soon".
     media_codec_->RequestKeyFrameSoon();
   }
-  scoped_refptr<VideoFrame> frame = input.a;
+  scoped_refptr<VideoFrame> frame = get<0>(input);
 
   uint8* buffer = NULL;
   size_t capacity = 0;
@@ -364,7 +364,8 @@ void AndroidVideoEncodeAccelerator::QueueInput() {
   fake_input_timestamp_ += base::TimeDelta::FromMicroseconds(1);
   status = media_codec_->QueueInputBuffer(
       input_buf_index, NULL, queued_size, fake_input_timestamp_);
-  UMA_HISTOGRAM_TIMES("Media.AVEA.InputQueueTime", base::Time::Now() - input.c);
+  UMA_HISTOGRAM_TIMES("Media.AVEA.InputQueueTime",
+                      base::Time::Now() - get<2>(input));
   RETURN_ON_FAILURE(status == media::MEDIA_CODEC_OK,
                     "Failed to QueueInputBuffer: " << status,
                     kPlatformFailureError);
diff --git a/content/common/gpu/media/android_video_encode_accelerator.h b/content/common/gpu/media/android_video_encode_accelerator.h
index f7f6eab..a587f10 100644
--- a/content/common/gpu/media/android_video_encode_accelerator.h
+++ b/content/common/gpu/media/android_video_encode_accelerator.h
@@ -86,7 +86,7 @@ class CONTENT_EXPORT AndroidVideoEncodeAccelerator
   // Frames waiting to be passed to the codec, queued until an input buffer is
   // available.  Each element is a tuple of <Frame, key_frame, enqueue_time>.
   typedef std::queue<
-      Tuple3<scoped_refptr<media::VideoFrame>, bool, base::Time> >
+      Tuple<scoped_refptr<media::VideoFrame>, bool, base::Time>>
       PendingFrames;
   PendingFrames pending_frames_;
 
diff --git a/content/common/gpu/media/video_decode_accelerator_unittest.cc b/content/common/gpu/media/video_decode_accelerator_unittest.cc
index b9fc7de5..9e97df3 100644
--- a/content/common/gpu/media/video_decode_accelerator_unittest.cc
+++ b/content/common/gpu/media/video_decode_accelerator_unittest.cc
@@ -1028,16 +1028,17 @@ void VideoDecodeAcceleratorTest::OutputLogFile(
 class VideoDecodeAcceleratorParamTest
     : public VideoDecodeAcceleratorTest,
       public ::testing::WithParamInterface<
-        Tuple7<int, int, int, ResetPoint, ClientState, bool, bool> > {
+        Tuple<int, int, int, ResetPoint, ClientState, bool, bool> > {
 };
 
 // Helper so that gtest failures emit a more readable version of the tuple than
 // its byte representation.
 ::std::ostream& operator<<(
     ::std::ostream& os,
-    const Tuple7<int, int, int, ResetPoint, ClientState, bool, bool>& t) {
-  return os << t.a << ", " << t.b << ", " << t.c << ", " << t.d << ", " << t.e
-            << ", " << t.f << ", " << t.g;
+    const Tuple<int, int, int, ResetPoint, ClientState, bool, bool>& t) {
+  return os << get<0>(t) << ", " << get<1>(t) << ", " << get<2>(t) << ", "
+            << get<3>(t) << ", " << get<4>(t) << ", " << get<5>(t) << ", "
+            << get<6>(t);
 }
 
 // Wait for |note| to report a state and if it's not |expected_state| then
@@ -1061,13 +1062,13 @@ enum { kMinSupportedNumConcurrentDecoders = 3 };
 // Test the most straightforward case possible: data is decoded from a single
 // chunk and rendered to the screen.
 TEST_P(VideoDecodeAcceleratorParamTest, TestSimpleDecode) {
-  size_t num_concurrent_decoders = GetParam().a;
-  const size_t num_in_flight_decodes = GetParam().b;
-  int num_play_throughs = GetParam().c;
-  const int reset_point = GetParam().d;
-  const int delete_decoder_state = GetParam().e;
-  bool test_reuse_delay = GetParam().f;
-  const bool render_as_thumbnails = GetParam().g;
+  size_t num_concurrent_decoders = get<0>(GetParam());
+  const size_t num_in_flight_decodes = get<1>(GetParam());
+  int num_play_throughs = get<2>(GetParam());
+  const int reset_point = get<3>(GetParam());
+  const int delete_decoder_state = get<4>(GetParam());
+  bool test_reuse_delay = get<5>(GetParam());
+  const bool render_as_thumbnails = get<6>(GetParam());
 
   if (test_video_files_.size() > 1)
     num_concurrent_decoders = test_video_files_.size();
diff --git a/content/common/gpu/media/video_encode_accelerator_unittest.cc b/content/common/gpu/media/video_encode_accelerator_unittest.cc
index 78e7f45..d35e2fd 100644
--- a/content/common/gpu/media/video_encode_accelerator_unittest.cc
+++ b/content/common/gpu/media/video_encode_accelerator_unittest.cc
@@ -1176,16 +1176,16 @@ class VideoEncodeAcceleratorTestEnvironment : public ::testing::Environment {
 // - If true, switch framerate mid-stream.
 class VideoEncodeAcceleratorTest
     : public ::testing::TestWithParam<
-          Tuple7<int, bool, int, bool, bool, bool, bool> > {};
+          Tuple<int, bool, int, bool, bool, bool, bool>> {};
 
 TEST_P(VideoEncodeAcceleratorTest, TestSimpleEncode) {
-  size_t num_concurrent_encoders = GetParam().a;
-  const bool save_to_file = GetParam().b;
-  const unsigned int keyframe_period = GetParam().c;
-  const bool force_bitrate = GetParam().d;
-  const bool test_perf = GetParam().e;
-  const bool mid_stream_bitrate_switch = GetParam().f;
-  const bool mid_stream_framerate_switch = GetParam().g;
+  size_t num_concurrent_encoders = get<0>(GetParam());
+  const bool save_to_file = get<1>(GetParam());
+  const unsigned int keyframe_period = get<2>(GetParam());
+  const bool force_bitrate = get<3>(GetParam());
+  const bool test_perf = get<4>(GetParam());
+  const bool mid_stream_bitrate_switch = get<5>(GetParam());
+  const bool mid_stream_framerate_switch = get<6>(GetParam());
 
   ScopedVector<ClientStateNotification<ClientState> > notes;
   ScopedVector<VEAClient> clients;
diff --git a/content/renderer/accessibility/renderer_accessibility_browsertest.cc b/content/renderer/accessibility/renderer_accessibility_browsertest.cc
index efa86e1..3af7488 100644
--- a/content/renderer/accessibility/renderer_accessibility_browsertest.cc
+++ b/content/renderer/accessibility/renderer_accessibility_browsertest.cc
@@ -59,10 +59,10 @@ class RendererAccessibilityTest : public RenderViewTest {
     const IPC::Message* message =
         sink_->GetUniqueMessageMatching(AccessibilityHostMsg_Events::ID);
     ASSERT_TRUE(message);
-    Tuple2<std::vector<AccessibilityHostMsg_EventParams>, int> param;
+    Tuple<std::vector<AccessibilityHostMsg_EventParams>, int> param;
     AccessibilityHostMsg_Events::Read(message, &param);
-    ASSERT_GE(param.a.size(), 1U);
-    *params = param.a[0];
+    ASSERT_GE(get<0>(param).size(), 1U);
+    *params = get<0>(param)[0];
   }
 
   int CountAccessibilityNodesSentToBrowser() {
@@ -405,9 +405,9 @@ TEST_F(RendererAccessibilityTest, EventOnObjectNotInTree) {
   const IPC::Message* message =
       sink_->GetUniqueMessageMatching(AccessibilityHostMsg_Events::ID);
   ASSERT_TRUE(message);
-  Tuple2<std::vector<AccessibilityHostMsg_EventParams>, int> param;
+  Tuple<std::vector<AccessibilityHostMsg_EventParams>, int> param;
   AccessibilityHostMsg_Events::Read(message, &param);
-  ASSERT_EQ(0U, param.a.size());
+  ASSERT_EQ(0U, get<0>(param).size());
 }
 
 }  // namespace content
diff --git a/content/renderer/browser_plugin/browser_plugin.cc b/content/renderer/browser_plugin/browser_plugin.cc
index 5551e7b..44b2328c 100644
--- a/content/renderer/browser_plugin/browser_plugin.cc
+++ b/content/renderer/browser_plugin/browser_plugin.cc
@@ -187,14 +187,15 @@ void BrowserPlugin::OnCompositorFrameSwapped(const IPC::Message& message) {
   guest_crashed_ = false;
 
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
-  param.b.frame.AssignTo(frame.get());
+  get<1>(param).frame.AssignTo(frame.get());
 
   EnableCompositing(true);
-  compositing_helper_->OnCompositorFrameSwapped(frame.Pass(),
-                                                param.b.producing_route_id,
-                                                param.b.output_surface_id,
-                                                param.b.producing_host_id,
-                                                param.b.shared_memory_handle);
+  compositing_helper_->OnCompositorFrameSwapped(
+      frame.Pass(),
+      get<1>(param).producing_route_id,
+      get<1>(param).output_surface_id,
+      get<1>(param).producing_host_id,
+      get<1>(param).shared_memory_handle);
 }
 
 void BrowserPlugin::OnGuestGone(int browser_plugin_instance_id) {
diff --git a/content/renderer/browser_plugin/browser_plugin_manager.cc b/content/renderer/browser_plugin/browser_plugin_manager.cc
index 7464d70..51a1fbd 100644
--- a/content/renderer/browser_plugin/browser_plugin_manager.cc
+++ b/content/renderer/browser_plugin/browser_plugin_manager.cc
@@ -132,11 +132,11 @@ void BrowserPluginManager::OnCompositorFrameSwappedPluginUnavailable(
     return;
 
   FrameHostMsg_CompositorFrameSwappedACK_Params params;
-  params.producing_host_id = param.b.producing_host_id;
-  params.producing_route_id = param.b.producing_route_id;
-  params.output_surface_id = param.b.output_surface_id;
+  params.producing_host_id = get<1>(param).producing_host_id;
+  params.producing_route_id = get<1>(param).producing_route_id;
+  params.output_surface_id = get<1>(param).output_surface_id;
   Send(new BrowserPluginHostMsg_CompositorFrameSwappedACK(
-      message.routing_id(), param.a, params));
+      message.routing_id(), get<0>(param), params));
 }
 
 }  // namespace content
diff --git a/content/renderer/external_popup_menu_browsertest.cc b/content/renderer/external_popup_menu_browsertest.cc
index cadb51f..b3fecbb 100644
--- a/content/renderer/external_popup_menu_browsertest.cc
+++ b/content/renderer/external_popup_menu_browsertest.cc
@@ -86,10 +86,10 @@ TEST_F(ExternalPopupMenuTest, NormalCase) {
   const IPC::Message* message =
       sink.GetUniqueMessageMatching(FrameHostMsg_ShowPopup::ID);
   ASSERT_TRUE(message != NULL);
-  Tuple1<FrameHostMsg_ShowPopup_Params> param;
+  Tuple<FrameHostMsg_ShowPopup_Params> param;
   FrameHostMsg_ShowPopup::Read(message, &param);
-  ASSERT_EQ(3U, param.a.popup_items.size());
-  EXPECT_EQ(1, param.a.selected_item);
+  ASSERT_EQ(3U, get<0>(param).popup_items.size());
+  EXPECT_EQ(1, get<0>(param).selected_item);
 
   // Simulate the user canceling the popup; the index should not have changed.
   frame()->OnSelectPopupMenuItem(-1);
@@ -106,8 +106,8 @@ TEST_F(ExternalPopupMenuTest, NormalCase) {
   message = sink.GetUniqueMessageMatching(FrameHostMsg_ShowPopup::ID);
   ASSERT_TRUE(message != NULL);
   FrameHostMsg_ShowPopup::Read(message, &param);
-  ASSERT_EQ(3U, param.a.popup_items.size());
-  EXPECT_EQ(0, param.a.selected_item);
+  ASSERT_EQ(3U, get<0>(param).popup_items.size());
+  EXPECT_EQ(0, get<0>(param).selected_item);
 }
 
 // Page shows popup, then navigates away while popup showing, then select.
@@ -189,11 +189,11 @@ TEST_F(ExternalPopupMenuDisplayNoneTest, SelectItem) {
   const IPC::Message* message =
       sink.GetUniqueMessageMatching(FrameHostMsg_ShowPopup::ID);
   ASSERT_TRUE(message != NULL);
-  Tuple1<FrameHostMsg_ShowPopup_Params> param;
+  Tuple<FrameHostMsg_ShowPopup_Params> param;
   FrameHostMsg_ShowPopup::Read(message, &param);
   // Number of items should match item count minus the number
   // of "display: none" items.
-  ASSERT_EQ(5U, param.a.popup_items.size());
+  ASSERT_EQ(5U, get<0>(param).popup_items.size());
 
   // Select index 1 item. This should select item with index 2,
   // skipping the item with 'display: none'
diff --git a/content/renderer/input/input_event_filter.cc b/content/renderer/input/input_event_filter.cc
index aca0cbc..be963cf 100644
--- a/content/renderer/input/input_event_filter.cc
+++ b/content/renderer/input/input_event_filter.cc
@@ -146,9 +146,9 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
   InputMsg_HandleInputEvent::Param params;
   if (!InputMsg_HandleInputEvent::Read(&message, &params))
     return;
-  const WebInputEvent* event = params.a;
-  ui::LatencyInfo latency_info = params.b;
-  bool is_keyboard_shortcut = params.c;
+  const WebInputEvent* event = get<0>(params);
+  ui::LatencyInfo latency_info = get<1>(params);
+  bool is_keyboard_shortcut = get<2>(params);
   DCHECK(event);
 
   const bool send_ack = !WebInputEventTraits::IgnoresAckDisposition(*event);
diff --git a/content/renderer/input/input_event_filter_unittest.cc b/content/renderer/input/input_event_filter_unittest.cc
index df08796..79cb66c 100644
--- a/content/renderer/input/input_event_filter_unittest.cc
+++ b/content/renderer/input/input_event_filter_unittest.cc
@@ -179,8 +179,8 @@ TEST_F(InputEventFilterTest, Basic) {
 
     InputHostMsg_HandleInputEvent_ACK::Param params;
     EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message, &params));
-    WebInputEvent::Type event_type = params.a.type;
-    InputEventAckState ack_result = params.a.state;
+    WebInputEvent::Type event_type = get<0>(params).type;
+    InputEventAckState ack_result = get<0>(params).state;
 
     EXPECT_EQ(kEvents[i].type, event_type);
     EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
@@ -205,7 +205,7 @@ TEST_F(InputEventFilterTest, Basic) {
     ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
     InputMsg_HandleInputEvent::Param params;
     EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
-    const WebInputEvent* event = params.a;
+    const WebInputEvent* event = get<0>(params);
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
@@ -231,8 +231,8 @@ TEST_F(InputEventFilterTest, Basic) {
 
     InputHostMsg_HandleInputEvent_ACK::Param params;
     EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message, &params));
-    WebInputEvent::Type event_type = params.a.type;
-    InputEventAckState ack_result = params.a.state;
+    WebInputEvent::Type event_type = get<0>(params).type;
+    InputEventAckState ack_result = get<0>(params).state;
     EXPECT_EQ(kEvents[i].type, event_type);
     EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_CONSUMED);
   }
diff --git a/content/renderer/media/render_media_log_unittest.cc b/content/renderer/media/render_media_log_unittest.cc
index a5d25ce..0ca11f0 100644
--- a/content/renderer/media/render_media_log_unittest.cc
+++ b/content/renderer/media/render_media_log_unittest.cc
@@ -36,9 +36,9 @@ class RenderMediaLogTest : public testing::Test {
       return std::vector<media::MediaLogEvent>();
     }
 
-    Tuple1<std::vector<media::MediaLogEvent> > events;
+    Tuple<std::vector<media::MediaLogEvent>> events;
     ViewHostMsg_MediaLogEvents::Read(msg, &events);
-    return events.a;
+    return get<0>(events);
   }
 
  private:
diff --git a/content/renderer/pepper/pepper_file_chooser_host_unittest.cc b/content/renderer/pepper/pepper_file_chooser_host_unittest.cc
index 3df6520..bfc88e6 100644
--- a/content/renderer/pepper/pepper_file_chooser_host_unittest.cc
+++ b/content/renderer/pepper/pepper_file_chooser_host_unittest.cc
@@ -91,7 +91,7 @@ TEST_F(PepperFileChooserHostTest, Show) {
   ASSERT_TRUE(msg);
   ViewHostMsg_RunFileChooser::Schema::Param call_msg_param;
   ASSERT_TRUE(ViewHostMsg_RunFileChooser::Read(msg, &call_msg_param));
-  const FileChooserParams& chooser_params = call_msg_param.a;
+  const FileChooserParams& chooser_params = get<0>(call_msg_param);
 
   // Basic validation of request.
   EXPECT_EQ(FileChooserParams::Open, chooser_params.mode);
@@ -123,7 +123,7 @@ TEST_F(PepperFileChooserHostTest, Show) {
   ASSERT_TRUE(
       PpapiPluginMsg_FileChooser_ShowReply::Read(&reply_msg, &reply_msg_param));
   const std::vector<ppapi::FileRefCreateInfo>& chooser_results =
-      reply_msg_param.a;
+      get<0>(reply_msg_param);
   ASSERT_EQ(1u, chooser_results.size());
   EXPECT_EQ(FilePathToUTF8(selected_info.display_name),
             chooser_results[0].display_name);
diff --git a/content/renderer/pepper/plugin_power_saver_helper_browsertest.cc b/content/renderer/pepper/plugin_power_saver_helper_browsertest.cc
index 9184301..60b40f0 100644
--- a/content/renderer/pepper/plugin_power_saver_helper_browsertest.cc
+++ b/content/renderer/pepper/plugin_power_saver_helper_browsertest.cc
@@ -165,7 +165,7 @@ TEST_F(PluginPowerSaverHelperTest, TemporaryOriginWhitelist) {
   EXPECT_EQ(FrameHostMsg_PluginContentOriginAllowed::ID, msg->type());
   FrameHostMsg_PluginContentOriginAllowed::Param params;
   FrameHostMsg_PluginContentOriginAllowed::Read(msg, &params);
-  EXPECT_EQ(GURL("http://b.com"), params.a);
+  EXPECT_EQ(GURL("http://b.com"), get<0>(params));
 }
 
 TEST_F(PluginPowerSaverHelperTest, UnthrottleOnExPostFactoWhitelist) {
diff --git a/content/renderer/render_frame_proxy.cc b/content/renderer/render_frame_proxy.cc
index 69194cb..635965a 100644
--- a/content/renderer/render_frame_proxy.cc
+++ b/content/renderer/render_frame_proxy.cc
@@ -196,18 +196,19 @@ void RenderFrameProxy::OnCompositorFrameSwapped(const IPC::Message& message) {
     return;
 
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
-  param.a.frame.AssignTo(frame.get());
+  get<0>(param).frame.AssignTo(frame.get());
 
   if (!compositing_helper_.get()) {
     compositing_helper_ =
         ChildFrameCompositingHelper::CreateForRenderFrameProxy(this);
     compositing_helper_->EnableCompositing(true);
   }
-  compositing_helper_->OnCompositorFrameSwapped(frame.Pass(),
-                                                param.a.producing_route_id,
-                                                param.a.output_surface_id,
-                                                param.a.producing_host_id,
-                                                param.a.shared_memory_handle);
+  compositing_helper_->OnCompositorFrameSwapped(
+      frame.Pass(),
+      get<0>(param).producing_route_id,
+      get<0>(param).output_surface_id,
+      get<0>(param).producing_host_id,
+      get<0>(param).shared_memory_handle);
 }
 
 void RenderFrameProxy::OnDisownOpener() {
diff --git a/content/renderer/render_view_browsertest.cc b/content/renderer/render_view_browsertest.cc
index ff439c4..5349aaf 100644
--- a/content/renderer/render_view_browsertest.cc
+++ b/content/renderer/render_view_browsertest.cc
@@ -303,8 +303,8 @@ TEST_F(RenderViewImplTest, SaveImageFromDataURL) {
 
   ViewHostMsg_SaveImageFromDataURL::Param param1;
   ViewHostMsg_SaveImageFromDataURL::Read(msg2, &param1);
-  EXPECT_EQ(param1.b.length(), image_data_url.length());
-  EXPECT_EQ(param1.b, image_data_url);
+  EXPECT_EQ(get<1>(param1).length(), image_data_url.length());
+  EXPECT_EQ(get<1>(param1), image_data_url);
 
   ProcessPendingMessages();
   render_thread_->sink().ClearMessages();
@@ -319,8 +319,8 @@ TEST_F(RenderViewImplTest, SaveImageFromDataURL) {
 
   ViewHostMsg_SaveImageFromDataURL::Param param2;
   ViewHostMsg_SaveImageFromDataURL::Read(msg3, &param2);
-  EXPECT_EQ(param2.b.length(), large_data_url.length());
-  EXPECT_EQ(param2.b, large_data_url);
+  EXPECT_EQ(get<1>(param2).length(), large_data_url.length());
+  EXPECT_EQ(get<1>(param2), large_data_url);
 
   ProcessPendingMessages();
   render_thread_->sink().ClearMessages();
@@ -386,12 +386,12 @@ TEST_F(RenderViewImplTest, OnNavigationHttpPost) {
   FrameHostMsg_DidCommitProvisionalLoad::Param host_nav_params;
   FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg,
                                               &host_nav_params);
-  EXPECT_TRUE(host_nav_params.a.is_post);
+  EXPECT_TRUE(get<0>(host_nav_params).is_post);
 
   // Check post data sent to browser matches
-  EXPECT_TRUE(host_nav_params.a.page_state.IsValid());
+  EXPECT_TRUE(get<0>(host_nav_params).page_state.IsValid());
   scoped_ptr<HistoryEntry> entry =
-      PageStateToHistoryEntry(host_nav_params.a.page_state);
+      PageStateToHistoryEntry(get<0>(host_nav_params).page_state);
   blink::WebHTTPBody body = entry->root().httpBody();
   blink::WebHTTPBody::Element element;
   bool successful = body.elementAt(0, element);
@@ -600,8 +600,8 @@ TEST_F(RenderViewImplTest, ReloadWhileSwappedOut) {
   ASSERT_TRUE(msg_A);
   ViewHostMsg_UpdateState::Param params;
   ViewHostMsg_UpdateState::Read(msg_A, &params);
-  int page_id_A = params.a;
-  PageState state_A = params.b;
+  int page_id_A = get<0>(params);
+  PageState state_A = get<1>(params);
   EXPECT_EQ(1, page_id_A);
   render_thread_->sink().ClearMessages();
 
@@ -657,7 +657,7 @@ TEST_F(RenderViewImplTest, ReloadWhileSwappedOut) {
   FrameHostMsg_DidCommitProvisionalLoad::Param commit_params;
   FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg,
                                               &commit_params);
-  EXPECT_NE(GURL("swappedout://"), commit_params.a.url);
+  EXPECT_NE(GURL("swappedout://"), get<0>(commit_params).url);
 }
 
 // Verify that security origins are replicated properly to RenderFrameProxies
@@ -716,8 +716,8 @@ TEST_F(RenderViewImplTest,  DISABLED_LastCommittedUpdateState) {
   ASSERT_TRUE(msg_A);
   ViewHostMsg_UpdateState::Param param;
   ViewHostMsg_UpdateState::Read(msg_A, &param);
-  int page_id_A = param.a;
-  PageState state_A = param.b;
+  int page_id_A = get<0>(param);
+  PageState state_A = get<1>(param);
   EXPECT_EQ(1, page_id_A);
   render_thread_->sink().ClearMessages();
 
@@ -730,8 +730,8 @@ TEST_F(RenderViewImplTest,  DISABLED_LastCommittedUpdateState) {
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_B);
   ViewHostMsg_UpdateState::Read(msg_B, &param);
-  int page_id_B = param.a;
-  PageState state_B = param.b;
+  int page_id_B = get<0>(param);
+  PageState state_B = get<1>(param);
   EXPECT_EQ(2, page_id_B);
   EXPECT_NE(state_A, state_B);
   render_thread_->sink().ClearMessages();
@@ -745,8 +745,8 @@ TEST_F(RenderViewImplTest,  DISABLED_LastCommittedUpdateState) {
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg_C);
   ViewHostMsg_UpdateState::Read(msg_C, &param);
-  int page_id_C = param.a;
-  PageState state_C = param.b;
+  int page_id_C = get<0>(param);
+  PageState state_C = get<1>(param);
   EXPECT_EQ(3, page_id_C);
   EXPECT_NE(state_B, state_C);
   render_thread_->sink().ClearMessages();
@@ -803,8 +803,8 @@ TEST_F(RenderViewImplTest,  DISABLED_LastCommittedUpdateState) {
       ViewHostMsg_UpdateState::ID);
   ASSERT_TRUE(msg);
   ViewHostMsg_UpdateState::Read(msg, &param);
-  int page_id = param.a;
-  PageState state = param.b;
+  int page_id = get<0>(param);
+  PageState state = get<1>(param);
   EXPECT_EQ(page_id_C, page_id);
   EXPECT_NE(state_A, state);
   EXPECT_NE(state_B, state);
@@ -831,8 +831,8 @@ TEST_F(RenderViewImplTest, StaleNavigationsIgnored) {
   ASSERT_TRUE(msg_A);
   ViewHostMsg_UpdateState::Param param;
   ViewHostMsg_UpdateState::Read(msg_A, &param);
-  int page_id_A = param.a;
-  PageState state_A = param.b;
+  int page_id_A = get<0>(param);
+  PageState state_A = get<1>(param);
   EXPECT_EQ(1, page_id_A);
   render_thread_->sink().ClearMessages();
 
@@ -953,9 +953,9 @@ TEST_F(RenderViewImplTest, OnImeTypeChanged) {
     EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type());
     ViewHostMsg_TextInputTypeChanged::Param params;
     ViewHostMsg_TextInputTypeChanged::Read(msg, &params);
-    ui::TextInputType type = params.a;
-    ui::TextInputMode input_mode = params.b;
-    bool can_compose_inline = params.c;
+    ui::TextInputType type = get<0>(params);
+    ui::TextInputMode input_mode = get<1>(params);
+    bool can_compose_inline = get<2>(params);
     EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, type);
     EXPECT_EQ(true, can_compose_inline);
 
@@ -972,8 +972,8 @@ TEST_F(RenderViewImplTest, OnImeTypeChanged) {
     EXPECT_TRUE(msg != NULL);
     EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type());
     ViewHostMsg_TextInputTypeChanged::Read(msg, & params);
-    type = params.a;
-    input_mode = params.b;
+    type = get<0>(params);
+    input_mode = get<1>(params);
     EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, type);
 
     for (size_t i = 0; i < arraysize(kInputModeTestCases); i++) {
@@ -994,8 +994,8 @@ TEST_F(RenderViewImplTest, OnImeTypeChanged) {
       EXPECT_TRUE(msg != NULL);
       EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type());
       ViewHostMsg_TextInputTypeChanged::Read(msg, & params);
-      type = params.a;
-      input_mode = params.b;
+      type = get<0>(params);
+      input_mode = get<1>(params);
       EXPECT_EQ(test_case->expected_mode, input_mode);
     }
   }
@@ -2124,7 +2124,7 @@ TEST_F(RenderViewImplTest, FocusElementCallsFocusedNodeChanged) {
 
   ViewHostMsg_FocusedNodeChanged::Param params;
   ViewHostMsg_FocusedNodeChanged::Read(msg1, &params);
-  EXPECT_TRUE(params.a);
+  EXPECT_TRUE(get<0>(params));
   render_thread_->sink().ClearMessages();
 
   ExecuteJavaScript("document.getElementById('test2').focus();");
@@ -2132,7 +2132,7 @@ TEST_F(RenderViewImplTest, FocusElementCallsFocusedNodeChanged) {
         ViewHostMsg_FocusedNodeChanged::ID);
   EXPECT_TRUE(msg2);
   ViewHostMsg_FocusedNodeChanged::Read(msg2, &params);
-  EXPECT_TRUE(params.a);
+  EXPECT_TRUE(get<0>(params));
   render_thread_->sink().ClearMessages();
 
   view()->webview()->clearFocusedElement();
@@ -2140,7 +2140,7 @@ TEST_F(RenderViewImplTest, FocusElementCallsFocusedNodeChanged) {
         ViewHostMsg_FocusedNodeChanged::ID);
   EXPECT_TRUE(msg3);
   ViewHostMsg_FocusedNodeChanged::Read(msg3, &params);
-  EXPECT_FALSE(params.a);
+  EXPECT_FALSE(get<0>(params));
   render_thread_->sink().ClearMessages();
 }
 
diff --git a/content/renderer/render_widget_unittest.cc b/content/renderer/render_widget_unittest.cc
index e0dbc83..9e8ec4d 100644
--- a/content/renderer/render_widget_unittest.cc
+++ b/content/renderer/render_widget_unittest.cc
@@ -89,7 +89,7 @@ TEST_F(RenderWidgetUnittest, TouchHitTestSinglePoint) {
   EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type());
   InputHostMsg_HandleInputEvent_ACK::Param params;
   InputHostMsg_HandleInputEvent_ACK::Read(message, &params);
-  InputEventAckState ack_state = params.a.state;
+  InputEventAckState ack_state = get<0>(params).state;
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, ack_state);
   widget->sink()->ClearMessages();
 
@@ -103,7 +103,7 @@ TEST_F(RenderWidgetUnittest, TouchHitTestSinglePoint) {
   message = widget->sink()->GetMessageAt(0);
   EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type());
   InputHostMsg_HandleInputEvent_ACK::Read(message, &params);
-  ack_state = params.a.state;
+  ack_state = get<0>(params).state;
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_state);
   widget->sink()->ClearMessages();
 }
@@ -127,7 +127,7 @@ TEST_F(RenderWidgetUnittest, TouchHitTestMultiplePoints) {
   EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type());
   InputHostMsg_HandleInputEvent_ACK::Param params;
   InputHostMsg_HandleInputEvent_ACK::Read(message, &params);
-  InputEventAckState ack_state = params.a.state;
+  InputEventAckState ack_state = get<0>(params).state;
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, ack_state);
   widget->sink()->ClearMessages();
 
@@ -138,7 +138,7 @@ TEST_F(RenderWidgetUnittest, TouchHitTestMultiplePoints) {
   message = widget->sink()->GetMessageAt(0);
   EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type());
   InputHostMsg_HandleInputEvent_ACK::Read(message, &params);
-  ack_state = params.a.state;
+  ack_state = get<0>(params).state;
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_state);
   widget->sink()->ClearMessages();
 }
diff --git a/content/renderer/screen_orientation/screen_orientation_dispatcher_unittest.cc b/content/renderer/screen_orientation/screen_orientation_dispatcher_unittest.cc
index 4d77141..355c7f6 100644
--- a/content/renderer/screen_orientation/screen_orientation_dispatcher_unittest.cc
+++ b/content/renderer/screen_orientation/screen_orientation_dispatcher_unittest.cc
@@ -75,9 +75,9 @@ class ScreenOrientationDispatcherTest : public testing::Test {
         ScreenOrientationHostMsg_LockRequest::ID);
     EXPECT_TRUE(msg != NULL);
 
-    Tuple2<blink::WebScreenOrientationLockType,int> params;
+    Tuple<blink::WebScreenOrientationLockType,int> params;
     ScreenOrientationHostMsg_LockRequest::Read(msg, &params);
-    return params.b;
+    return get<1>(params);
   }
 
   IPC::TestSink& sink() {
diff --git a/extensions/renderer/guest_view/extensions_guest_view_container.cc b/extensions/renderer/guest_view/extensions_guest_view_container.cc
index c9ac941..ca5960d 100644
--- a/extensions/renderer/guest_view/extensions_guest_view_container.cc
+++ b/extensions/renderer/guest_view/extensions_guest_view_container.cc
@@ -79,7 +79,7 @@ void ExtensionsGuestViewContainer::AttachRequest::HandleResponse(
     return;
 
   content::RenderView* guest_proxy_render_view =
-      content::RenderView::FromRoutingID(param.b);
+      content::RenderView::FromRoutingID(get<1>(param));
   // TODO(fsamuel): Should we be reporting an error to JavaScript or DCHECKing?
   if (!guest_proxy_render_view)
     return;
diff --git a/ppapi/host/dispatch_host_message.h b/ppapi/host/dispatch_host_message.h
index 218b8f7..80b8a34 100644
--- a/ppapi/host/dispatch_host_message.h
+++ b/ppapi/host/dispatch_host_message.h
@@ -22,43 +22,45 @@ struct HostMessageContext;
 template <class ObjT, class Method>
 inline int32_t DispatchResourceCall(ObjT* obj, Method method,
                                     HostMessageContext* context,
-                                    Tuple0& arg) {
+                                    Tuple<>& arg) {
   return (obj->*method)(context);
 }
 
 template <class ObjT, class Method, class A>
 inline int32_t DispatchResourceCall(ObjT* obj, Method method,
                                     HostMessageContext* context,
-                                    Tuple1<A>& arg) {
-  return (obj->*method)(context, arg.a);
+                                    Tuple<A>& arg) {
+  return (obj->*method)(context, get<0>(arg));
 }
 
 template<class ObjT, class Method, class A, class B>
 inline int32_t DispatchResourceCall(ObjT* obj, Method method,
                                     HostMessageContext* context,
-                                    Tuple2<A, B>& arg) {
-  return (obj->*method)(context, arg.a, arg.b);
+                                    Tuple<A, B>& arg) {
+  return (obj->*method)(context, get<0>(arg), get<1>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C>
 inline int32_t DispatchResourceCall(ObjT* obj, Method method,
                                     HostMessageContext* context,
-                                    Tuple3<A, B, C>& arg) {
-  return (obj->*method)(context, arg.a, arg.b, arg.c);
+                                    Tuple<A, B, C>& arg) {
+  return (obj->*method)(context, get<0>(arg), get<1>(arg), get<2>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C, class D>
 inline int32_t DispatchResourceCall(ObjT* obj, Method method,
                                     HostMessageContext* context,
-                                    Tuple4<A, B, C, D>& arg) {
-  return (obj->*method)(context, arg.a, arg.b, arg.c, arg.d);
+                                    Tuple<A, B, C, D>& arg) {
+  return (obj->*method)(context, get<0>(arg), get<1>(arg), get<2>(arg),
+                        get<3>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C, class D, class E>
 inline int32_t DispatchResourceCall(ObjT* obj, Method method,
                                     HostMessageContext* context,
-                                    Tuple5<A, B, C, D, E>& arg) {
-  return (obj->*method)(context, arg.a, arg.b, arg.c, arg.d, arg.e);
+                                    Tuple<A, B, C, D, E>& arg) {
+  return (obj->*method)(context, get<0>(arg), get<1>(arg), get<2>(arg),
+                        get<3>(arg), get<4>(arg));
 }
 
 // Note that this only works for message with 1 or more parameters. For
diff --git a/ppapi/proxy/dispatch_reply_message.h b/ppapi/proxy/dispatch_reply_message.h
index bb4b7d7..3e8b74f 100644
--- a/ppapi/proxy/dispatch_reply_message.h
+++ b/ppapi/proxy/dispatch_reply_message.h
@@ -22,43 +22,44 @@ class ResourceMessageReplyParams;
 template <class ObjT, class Method>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const Tuple0& arg) {
+                                  const Tuple<>& arg) {
   (obj->*method)(params);
 }
 
 template <class ObjT, class Method, class A>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const Tuple1<A>& arg) {
-  (obj->*method)(params, arg.a);
+                                  const Tuple<A>& arg) {
+  (obj->*method)(params, get<0>(arg));
 }
 
 template<class ObjT, class Method, class A, class B>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const Tuple2<A, B>& arg) {
-  (obj->*method)(params, arg.a, arg.b);
+                                  const Tuple<A, B>& arg) {
+  (obj->*method)(params, get<0>(arg), get<1>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const Tuple3<A, B, C>& arg) {
-  (obj->*method)(params, arg.a, arg.b, arg.c);
+                                  const Tuple<A, B, C>& arg) {
+  (obj->*method)(params, get<0>(arg), get<1>(arg), get<2>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C, class D>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const Tuple4<A, B, C, D>& arg) {
-  (obj->*method)(params, arg.a, arg.b, arg.c, arg.d);
+                                  const Tuple<A, B, C, D>& arg) {
+  (obj->*method)(params, get<0>(arg), get<1>(arg), get<2>(arg), get<3>(arg));
 }
 
 template<class ObjT, class Method, class A, class B, class C, class D, class E>
 inline void DispatchResourceReply(ObjT* obj, Method method,
                                   const ResourceMessageReplyParams& params,
-                                  const Tuple5<A, B, C, D, E>& arg) {
-  (obj->*method)(params, arg.a, arg.b, arg.c, arg.d, arg.e);
+                                  const Tuple<A, B, C, D, E>& arg) {
+  (obj->*method)(params, get<0>(arg), get<1>(arg), get<2>(arg), get<3>(arg),
+                 get<4>(arg));
 }
 
 // Used to dispatch resource replies. In most cases, you should not call this
diff --git a/ppapi/proxy/nacl_message_scanner.cc b/ppapi/proxy/nacl_message_scanner.cc
index 4120beb..a31ba62 100644
--- a/ppapi/proxy/nacl_message_scanner.cc
+++ b/ppapi/proxy/nacl_message_scanner.cc
@@ -149,26 +149,26 @@ void ScanParam(const T& param, ScanningResults* results) {
 // The idea is to scan elements in the tuple which require special handling,
 // and write them into the |results| struct.
 template <class A>
-void ScanTuple(const Tuple1<A>& t1, ScanningResults* results) {
-  ScanParam(t1.a, results);
+void ScanTuple(const Tuple<A>& t1, ScanningResults* results) {
+  ScanParam(get<0>(t1), results);
 }
 template <class A, class B>
-void ScanTuple(const Tuple2<A, B>& t1, ScanningResults* results) {
-  ScanParam(t1.a, results);
-  ScanParam(t1.b, results);
+void ScanTuple(const Tuple<A, B>& t1, ScanningResults* results) {
+  ScanParam(get<0>(t1), results);
+  ScanParam(get<1>(t1), results);
 }
 template <class A, class B, class C>
-void ScanTuple(const Tuple3<A, B, C>& t1, ScanningResults* results) {
-  ScanParam(t1.a, results);
-  ScanParam(t1.b, results);
-  ScanParam(t1.c, results);
+void ScanTuple(const Tuple<A, B, C>& t1, ScanningResults* results) {
+  ScanParam(get<0>(t1), results);
+  ScanParam(get<1>(t1), results);
+  ScanParam(get<2>(t1), results);
 }
 template <class A, class B, class C, class D>
-void ScanTuple(const Tuple4<A, B, C, D>& t1, ScanningResults* results) {
-  ScanParam(t1.a, results);
-  ScanParam(t1.b, results);
-  ScanParam(t1.c, results);
-  ScanParam(t1.d, results);
+void ScanTuple(const Tuple<A, B, C, D>& t1, ScanningResults* results) {
+  ScanParam(get<0>(t1), results);
+  ScanParam(get<1>(t1), results);
+  ScanParam(get<2>(t1), results);
+  ScanParam(get<3>(t1), results);
 }
 
 template <class MessageType>
diff --git a/ppapi/proxy/plugin_var_tracker_unittest.cc b/ppapi/proxy/plugin_var_tracker_unittest.cc
index f43d7a8..fe0a82d 100644
--- a/ppapi/proxy/plugin_var_tracker_unittest.cc
+++ b/ppapi/proxy/plugin_var_tracker_unittest.cc
@@ -56,9 +56,9 @@ class PluginVarTrackerTest : public PluginProxyTest {
     if (!release_msg)
       return -1;
 
-    Tuple1<int64> id;
+    Tuple<int64> id;
     PpapiHostMsg_PPBVar_ReleaseObject::Read(release_msg, &id);
-    return id.a;
+    return get<0>(id);
   }
 };
 
diff --git a/ppapi/proxy/ppapi_message_utils.h b/ppapi/proxy/ppapi_message_utils.h
index 68667dd..38f623a 100644
--- a/ppapi/proxy/ppapi_message_utils.h
+++ b/ppapi/proxy/ppapi_message_utils.h
@@ -23,7 +23,7 @@ struct TupleTypeMatch1 {
   static const bool kValue = false;
 };
 template <class A>
-struct TupleTypeMatch1<Tuple1<A>, A> {
+struct TupleTypeMatch1<Tuple<A>, A> {
   static const bool kValue = true;
 };
 
@@ -32,7 +32,7 @@ struct TupleTypeMatch2 {
   static const bool kValue = false;
 };
 template <class A, class B>
-struct TupleTypeMatch2<Tuple2<A, B>, A, B> {
+struct TupleTypeMatch2<Tuple<A, B>, A, B> {
   static const bool kValue = true;
 };
 
@@ -41,7 +41,7 @@ struct TupleTypeMatch3 {
   static const bool kValue = false;
 };
 template <class A, class B, class C>
-struct TupleTypeMatch3<Tuple3<A, B, C>, A, B, C> {
+struct TupleTypeMatch3<Tuple<A, B, C>, A, B, C> {
   static const bool kValue = true;
 };
 
@@ -50,7 +50,7 @@ struct TupleTypeMatch4 {
   static const bool kValue = false;
 };
 template <class A, class B, class C, class D>
-struct TupleTypeMatch4<Tuple4<A, B, C, D>, A, B, C, D> {
+struct TupleTypeMatch4<Tuple<A, B, C, D>, A, B, C, D> {
   static const bool kValue = true;
 };
 
@@ -59,7 +59,7 @@ struct TupleTypeMatch5 {
   static const bool kValue = false;
 };
 template <class A, class B, class C, class D, class E>
-struct TupleTypeMatch5<Tuple5<A, B, C, D, E>, A, B, C, D, E> {
+struct TupleTypeMatch5<Tuple<A, B, C, D, E>, A, B, C, D, E> {
   static const bool kValue = true;
 };
 
@@ -128,4 +128,3 @@ bool UnpackMessage(const IPC::Message& msg, A* a, B* b, C* c, D* d, E* e) {
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_PPAPI_MESSAGE_UTILS_H_
-
diff --git a/ppapi/proxy/ppapi_proxy_test.cc b/ppapi/proxy/ppapi_proxy_test.cc
index 2c0b136..acd533f 100644
--- a/ppapi/proxy/ppapi_proxy_test.cc
+++ b/ppapi/proxy/ppapi_proxy_test.cc
@@ -142,7 +142,7 @@ bool ProxyTestHarnessBase::SupportsInterface(const char* name) {
       reply_msg, &reply_data));
 
   sink().ClearMessages();
-  return reply_data.a;
+  return get<0>(reply_data);
 }
 
 // PluginProxyTestHarness ------------------------------------------------------
diff --git a/ppapi/proxy/resource_message_test_sink.cc b/ppapi/proxy/resource_message_test_sink.cc
index 2c237b0..2ce9f41 100644
--- a/ppapi/proxy/resource_message_test_sink.cc
+++ b/ppapi/proxy/resource_message_test_sink.cc
@@ -24,8 +24,8 @@ GetAllResourceMessagesMatching(const ResourceMessageTestSink& sink,
     if (msg->type() == WrapperMessage::ID) {
       typename WrapperMessage::Param params;
       WrapperMessage::Read(msg, &params);
-      Params cur_params = params.a;
-      IPC::Message cur_msg = params.b;
+      Params cur_params = get<0>(params);
+      IPC::Message cur_msg = get<1>(params);
       if (cur_msg.type() == id) {
         result.push_back(std::make_pair(cur_params, cur_msg));
       }
@@ -130,8 +130,8 @@ bool ResourceSyncCallHandler::OnMessageReceived(const IPC::Message& msg) {
   bool success = PpapiHostMsg_ResourceSyncCall::ReadSendParam(
       &msg, &send_params);
   DCHECK(success);
-  ResourceMessageCallParams call_params = send_params.a;
-  IPC::Message call_msg = send_params.b;
+  ResourceMessageCallParams call_params = get<0>(send_params);
+  IPC::Message call_msg = get<1>(send_params);
   if (call_msg.type() != incoming_type_)
     return false;
   IPC::Message* wrapper_reply_msg = IPC::SyncMessage::GenerateReply(&msg);
diff --git a/ppapi/proxy/websocket_resource_unittest.cc b/ppapi/proxy/websocket_resource_unittest.cc
index eac6d8f..8c300ce 100644
--- a/ppapi/proxy/websocket_resource_unittest.cc
+++ b/ppapi/proxy/websocket_resource_unittest.cc
@@ -77,9 +77,9 @@ TEST_F(WebSocketResourceTest, Connect) {
       PpapiHostMsg_WebSocket_Connect::ID, &params, &msg));
   PpapiHostMsg_WebSocket_Connect::Schema::Param p;
   PpapiHostMsg_WebSocket_Connect::Read(&msg, &p);
-  EXPECT_EQ(url, p.a);
-  EXPECT_EQ(protocol0, p.b[0]);
-  EXPECT_EQ(protocol1, p.b[1]);
+  EXPECT_EQ(url, get<0>(p));
+  EXPECT_EQ(protocol0, get<1>(p)[0]);
+  EXPECT_EQ(protocol1, get<1>(p)[1]);
 
   // Synthesize a response.
   ResourceMessageReplyParams reply_params(params.pp_resource(),
diff --git a/printing/pdf_render_settings.h b/printing/pdf_render_settings.h
index 9e8f930..1de192d 100644
--- a/printing/pdf_render_settings.h
+++ b/printing/pdf_render_settings.h
@@ -16,7 +16,7 @@ namespace printing {
 // gfx::Rect - render area
 // int - render dpi
 // bool - autorotate pages to fit paper
-typedef Tuple3<gfx::Rect, int, bool> PdfRenderSettingsBase;
+typedef Tuple<gfx::Rect, int, bool> PdfRenderSettingsBase;
 
 class PdfRenderSettings : public PdfRenderSettingsBase {
  public:
@@ -25,9 +25,9 @@ class PdfRenderSettings : public PdfRenderSettingsBase {
       : PdfRenderSettingsBase(area, dpi, autorotate) {}
   ~PdfRenderSettings() {}
 
-  const gfx::Rect& area() const { return a; }
-  int dpi() const { return b; }
-  bool autorotate() const { return c; }
+  const gfx::Rect& area() const { return ::get<0>(*this); }
+  int dpi() const { return ::get<1>(*this); }
+  bool autorotate() const { return ::get<2>(*this); }
 };
 
 }  // namespace printing
diff --git a/ui/base/win/open_file_name_win.cc b/ui/base/win/open_file_name_win.cc
index 3914fa5..167609d 100644
--- a/ui/base/win/open_file_name_win.cc
+++ b/ui/base/win/open_file_name_win.cc
@@ -85,18 +85,15 @@ OpenFileName::~OpenFileName() {
 }
 
 void OpenFileName::SetFilters(
-    const std::vector<Tuple2<base::string16, base::string16> >& filters) {
+    const std::vector<Tuple<base::string16, base::string16>>& filters) {
   openfilename_.lpstrFilter = NULL;
   filter_buffer_.clear();
   if (filters.empty())
     return;
-  for (std::vector<Tuple2<base::string16, base::string16> >::const_iterator
-           it = filters.begin();
-       it != filters.end();
-       ++it) {
-    filter_buffer_.append(it->a);
+  for (const auto& filter : filters) {
+    filter_buffer_.append(get<0>(filter));
     filter_buffer_.push_back(0);
-    filter_buffer_.append(it->b);
+    filter_buffer_.append(get<1>(filter));
     filter_buffer_.push_back(0);
   }
   filter_buffer_.push_back(0);
@@ -205,9 +202,9 @@ void OpenFileName::SetResult(const base::FilePath& directory,
 }
 
 // static
-std::vector<Tuple2<base::string16, base::string16> > OpenFileName::GetFilters(
-    const OPENFILENAME* openfilename) {
-  std::vector<Tuple2<base::string16, base::string16> > filters;
+std::vector<Tuple<base::string16, base::string16>>
+OpenFileName::GetFilters(const OPENFILENAME* openfilename) {
+  std::vector<Tuple<base::string16, base::string16>> filters;
 
   const base::char16* display_string = openfilename->lpstrFilter;
   if (!display_string)
diff --git a/ui/base/win/open_file_name_win.h b/ui/base/win/open_file_name_win.h
index bdf01f4..1a3aab5 100644
--- a/ui/base/win/open_file_name_win.h
+++ b/ui/base/win/open_file_name_win.h
@@ -34,7 +34,7 @@ class UI_BASE_EXPORT OpenFileName {
 
   // Initializes |lpstrFilter| from the label/pattern pairs in |filters|.
   void SetFilters(
-      const std::vector<Tuple2<base::string16, base::string16> >& filters);
+      const std::vector<Tuple<base::string16, base::string16>>& filters);
 
   // Sets |lpstrInitialDir| and |lpstrFile|.
   void SetInitialSelection(const base::FilePath& initial_directory,
@@ -68,7 +68,7 @@ class UI_BASE_EXPORT OpenFileName {
 
   // Returns a vector of label/pattern pairs built from
   // |openfilename->lpstrFilter|.
-  static std::vector<Tuple2<base::string16, base::string16> > GetFilters(
+  static std::vector<Tuple<base::string16, base::string16>> GetFilters(
       const OPENFILENAME* openfilename);
 
  private:
diff --git a/ui/base/win/open_file_name_win_unittest.cc b/ui/base/win/open_file_name_win_unittest.cc
index 9eaee79..d359d9d 100644
--- a/ui/base/win/open_file_name_win_unittest.cc
+++ b/ui/base/win/open_file_name_win_unittest.cc
@@ -27,8 +27,8 @@ void SetResult(const base::string16& result, ui::win::OpenFileName* ofn) {
 }
 
 void CheckFilters(
-    const std::vector<Tuple2<base::string16, base::string16> >& expected,
-    const std::vector<Tuple2<base::string16, base::string16> >& actual) {
+    const std::vector<Tuple<base::string16, base::string16>>& expected,
+    const std::vector<Tuple<base::string16, base::string16>>& actual) {
   if (expected.size() != actual.size()) {
     ADD_FAILURE() << "filter count mismatch. Got " << actual.size()
                   << " expected " << expected.size() << ".";
@@ -36,8 +36,10 @@ void CheckFilters(
   }
 
   for (size_t i = 0; i < expected.size(); ++i) {
-    EXPECT_EQ(expected[i].a, actual[i].a) << "Mismatch at index " << i;
-    EXPECT_EQ(expected[i].b, actual[i].b) << "Mismatch at index " << i;
+    EXPECT_EQ(get<0>(expected[i]), get<0>(actual[i]))
+        << "Mismatch at index " << i;
+    EXPECT_EQ(get<1>(expected[i]), get<1>(actual[i]))
+        << "Mismatch at index " << i;
   }
 }
 
@@ -201,7 +203,7 @@ TEST(OpenFileNameTest, SetAndGetFilters) {
   const base::string16 kNull(L"\0", 1);
 
   ui::win::OpenFileName ofn(kHwnd, kFlags);
-  std::vector<Tuple2<base::string16, base::string16> > filters;
+  std::vector<Tuple<base::string16, base::string16>> filters;
   ofn.SetFilters(filters);
   EXPECT_FALSE(ofn.GetOPENFILENAME()->lpstrFilter);
   CheckFilters(filters,
diff --git a/ui/shell_dialogs/select_file_dialog_win.cc b/ui/shell_dialogs/select_file_dialog_win.cc
index 6e1a8ab..b963b06 100644
--- a/ui/shell_dialogs/select_file_dialog_win.cc
+++ b/ui/shell_dialogs/select_file_dialog_win.cc
@@ -516,12 +516,12 @@ bool SelectFileDialogImpl::SaveFileAsWithFilter(
   // Figure out what filter got selected. The filter index is 1-based.
   std::wstring filter_selected;
   if (*index > 0) {
-    std::vector<Tuple2<base::string16, base::string16> > filters =
+    std::vector<Tuple<base::string16, base::string16>> filters =
         ui::win::OpenFileName::GetFilters(save_as.GetOPENFILENAME());
     if (*index > filters.size())
       NOTREACHED() << "Invalid filter index.";
     else
-      filter_selected = filters[*index - 1].b;
+      filter_selected = get<1>(filters[*index - 1]);
   }
 
   // Get the extension that was suggested to the user (when the Save As dialog