diff --git a/base/observer_list_threadsafe.h b/base/observer_list_threadsafe.h index e0ce0daa90f74e..7ac1d6b4171899 100644 --- a/base/observer_list_threadsafe.h +++ b/base/observer_list_threadsafe.h @@ -172,8 +172,8 @@ class ObserverListThreadSafe void Notify(const tracked_objects::Location& from_here, Method m, const Params&... params) { - UnboundMethod> method( - m, MakeTuple(params...)); + UnboundMethod> method( + m, base::MakeTuple(params...)); base::AutoLock lock(list_lock_); for (const auto& entry : observer_lists_) { @@ -182,7 +182,7 @@ class ObserverListThreadSafe from_here, base::Bind( &ObserverListThreadSafe::template NotifyWrapper< - Method, Tuple>, + Method, base::Tuple>, this, context, method)); } } diff --git a/base/tuple.h b/base/tuple.h index 4628aa9417c395..ef51d85fed9e7e 100644 --- a/base/tuple.h +++ b/base/tuple.h @@ -30,6 +30,8 @@ #include "base/bind_helpers.h" +namespace base { + // Index sequences // // Minimal clone of the similarly-named C++14 functionality. @@ -181,9 +183,9 @@ struct TupleLeaf { // Allows accessing an arbitrary tuple element by index. // // Example usage: -// Tuple t2; -// get<0>(t2) = 42; -// get<1>(t2) = 3.14; +// base::Tuple t2; +// base::get<0>(t2) = 42; +// base::get<1>(t2) = 3.14; template T& get(TupleLeaf& leaf) { @@ -329,4 +331,6 @@ inline void DispatchToMethod(ObjT* obj, MakeIndexSequence()); } +} // namespace base + #endif // BASE_TUPLE_H_ diff --git a/base/tuple_unittest.cc b/base/tuple_unittest.cc index 5b43affc600f5f..55a91392353076 100644 --- a/base/tuple_unittest.cc +++ b/base/tuple_unittest.cc @@ -7,6 +7,8 @@ #include "base/compiler_specific.h" #include "testing/gtest/include/gtest/gtest.h" +namespace base { + namespace { void DoAdd(int a, int b, int c, int* res) { @@ -30,14 +32,15 @@ struct Addz { } // namespace TEST(TupleTest, Basic) { - Tuple<> t0 = MakeTuple(); + base::Tuple<> t0 = base::MakeTuple(); ALLOW_UNUSED_LOCAL(t0); - Tuple t1(1); - Tuple t2 = MakeTuple(1, static_cast("wee")); - Tuple t3(1, 2, 3); - Tuple t4(1, 2, 3, &get<0>(t1)); - Tuple t5(1, 2, 3, 4, &get<0>(t4)); - Tuple t6(1, 2, 3, 4, 5, &get<0>(t4)); + base::Tuple t1(1); + base::Tuple t2 = + base::MakeTuple(1, static_cast("wee")); + base::Tuple t3(1, 2, 3); + base::Tuple t4(1, 2, 3, &get<0>(t1)); + base::Tuple t5(1, 2, 3, 4, &get<0>(t4)); + base::Tuple t6(1, 2, 3, 4, 5, &get<0>(t4)); EXPECT_EQ(1, get<0>(t1)); EXPECT_EQ(1, get<0>(t2)); @@ -62,7 +65,7 @@ TEST(TupleTest, Basic) { EXPECT_EQ(6, get<0>(t1)); int res = 0; - DispatchToFunction(&DoAdd, MakeTuple(9, 8, 7, &res)); + DispatchToFunction(&DoAdd, base::MakeTuple(9, 8, 7, &res)); EXPECT_EQ(24, res); Addy addy; @@ -108,7 +111,7 @@ TEST(TupleTest, Copying) { bool res = false; // Creating the tuple should copy the class to store internally in the tuple. - Tuple tuple(logger, &logger, &res); + base::Tuple tuple(logger, &logger, &res); get<1>(tuple) = &get<0>(tuple); EXPECT_EQ(2, CopyLogger::TimesConstructed); EXPECT_EQ(1, CopyLogger::TimesCopied); @@ -127,3 +130,5 @@ TEST(TupleTest, Copying) { EXPECT_EQ(3, CopyLogger::TimesConstructed); EXPECT_EQ(2, CopyLogger::TimesCopied); } + +} // namespace base 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 dbe9f734030311..e20a9b5fcb2ed5 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, ¶m); - return get<0>(param); + return base::get<0>(param); } void SimulateDisconnect() { 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 81e586ed0aa840..797bde9c30e62b 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 @@ -121,9 +121,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(get<3>(*param).GetSize(), 2u); + ASSERT_GE(base::get<3>(*param).GetSize(), 2u); const base::Value* value = NULL; - ASSERT_TRUE(get<3>(*param).Get(1, &value)); + ASSERT_TRUE(base::get<3>(*param).Get(1, &value)); const base::ListValue* list = NULL; ASSERT_TRUE(value->GetAsList(&list)); ASSERT_EQ(1u, list->GetSize()); @@ -925,7 +925,7 @@ TEST_P(ExtensionWebRequestHeaderModificationTest, TestModifications) { continue; ExtensionMsg_MessageInvoke::Param message_tuple; ExtensionMsg_MessageInvoke::Read(message, &message_tuple); - base::ListValue& args = get<3>(message_tuple); + base::ListValue& args = base::get<3>(message_tuple); std::string event_name; if (!args.GetString(0, &event_name) || 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 9fd9e18700ebf0..ffdcd0cb2a13ff 100644 --- a/chrome/browser/password_manager/chrome_password_manager_client_unittest.cc +++ b/chrome/browser/password_manager/chrome_password_manager_client_unittest.cc @@ -119,9 +119,9 @@ bool ChromePasswordManagerClientTest::WasLoggingActivationMessageSent( process()->sink().GetFirstMessageMatching(kMsgID); if (!message) return false; - Tuple param; + base::Tuple param; AutofillMsg_SetLoggingState::Read(message, ¶m); - *activation_flag = get<0>(param); + *activation_flag = base::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 6f8249ceb9e2c8..fc2d6e5696d722 100644 --- a/chrome/browser/safe_browsing/client_side_detection_host_unittest.cc +++ b/chrome/browser/safe_browsing/client_side_detection_host_unittest.cc @@ -325,9 +325,9 @@ class ClientSideDetectionHostTest : public ChromeRenderViewHostTestHarness { SafeBrowsingMsg_StartPhishingDetection::ID); if (url) { ASSERT_TRUE(msg); - Tuple actual_url; + base::Tuple actual_url; SafeBrowsingMsg_StartPhishingDetection::Read(msg, &actual_url); - EXPECT_EQ(*url, get<0>(actual_url)); + EXPECT_EQ(*url, base::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 66253b745747db..4b5d0f7d5916c1 100644 --- a/chrome/browser/search/instant_service_unittest.cc +++ b/chrome/browser/search/instant_service_unittest.cc @@ -109,8 +109,8 @@ TEST_F(InstantServiceEnabledTest, SendsSearchURLsToRenderer) { ASSERT_TRUE(msg); ChromeViewMsg_SetSearchURLs::Param params; ChromeViewMsg_SetSearchURLs::Read(msg, ¶ms); - std::vector search_urls = get<0>(params); - GURL new_tab_page_url = get<1>(params); + std::vector search_urls = base::get<0>(params); + GURL new_tab_page_url = base::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 52aececf9a182f..08ef6c68860fff 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], ¶ms); - std::vector sent_results = get<1>(params); + std::vector sent_results = base::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 0e98efeac7b12a..432f43bfe0fc0a 100644 --- a/chrome/browser/spellchecker/spellcheck_message_filter_unittest.cc +++ b/chrome/browser/spellchecker/spellcheck_message_filter_unittest.cc @@ -104,10 +104,10 @@ TEST(SpellCheckMessageFilterTest, OnTextCheckCompleteTestCustomDictionary) { SpellCheckMsg_RespondSpellingService::Param params; bool ok = SpellCheckMsg_RespondSpellingService::Read( filter->sent_messages[0], ¶ms); - int sent_identifier = get<0>(params); - bool sent_success = get<1>(params); - base::string16 sent_text = get<2>(params); - std::vector sent_results = get<3>(params); + int sent_identifier = base::get<0>(params); + bool sent_success = base::get<1>(params); + base::string16 sent_text = base::get<2>(params); + std::vector sent_results = base::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 = get<2>(params); - std::vector sent_results = get<3>(params); + base::string16 sent_text = base::get<2>(params); + std::vector sent_results = base::get<3>(params); EXPECT_TRUE(ok); EXPECT_EQ(static_cast(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 4eb0792a800841..ec7a7a44bbe228 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; - Tuple translate_param; + base::Tuple translate_param; ChromeViewMsg_TranslatePage::Read(message, &translate_param); // 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 = get<2>(translate_param); + *original_lang = base::get<2>(translate_param); if (target_lang) - *target_lang = get<3>(translate_param); + *target_lang = base::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 23ffae6731f8db..07d73ab75c7f15 100644 --- a/chrome/browser/ui/search/instant_search_prerenderer_unittest.cc +++ b/chrome/browser/ui/search/instant_search_prerenderer_unittest.cc @@ -529,13 +529,13 @@ TEST_F(TestUsePrerenderPage, SetEmbeddedSearchRequestParams) { ASSERT_TRUE(message); // Verify the IPC message params. - Tuple params; + base::Tuple params; ChromeViewMsg_SearchBoxSubmit::Read(message, ¶ms); - 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("foo", base::UTF16ToASCII(base::get<0>(params))); + EXPECT_EQ("f", base::UTF16ToASCII(base::get<1>(params).original_query)); + EXPECT_EQ("utf-8", base::UTF16ToASCII(base::get<1>(params).input_encoding)); + EXPECT_EQ("", base::UTF16ToASCII(base::get<1>(params).rlz_parameter_value)); EXPECT_EQ("chrome...0", - base::UTF16ToASCII(get<1>(params).assisted_query_stats)); + base::UTF16ToASCII(base::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 224c714701aab8..fac9a27324f493 100644 --- a/chrome/browser/ui/search/search_ipc_router_unittest.cc +++ b/chrome/browser/ui/search/search_ipc_router_unittest.cc @@ -162,10 +162,11 @@ class SearchIPCRouterTest : public BrowserWithTestWindowTest { const IPC::Message* message = process()->sink().GetFirstMessageMatching( ChromeViewMsg_SearchBoxSetDisplayInstantResults::ID); EXPECT_NE(static_cast(NULL), message); - Tuple display_instant_results_param; + base::Tuple display_instant_results_param; ChromeViewMsg_SearchBoxSetDisplayInstantResults::Read( message, &display_instant_results_param); - EXPECT_EQ(expected_param_value, get<0>(display_instant_results_param)); + EXPECT_EQ(expected_param_value, + base::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 850a57409063d1..71af90e6df49b2 100644 --- a/chrome/browser/ui/search/search_tab_helper_unittest.cc +++ b/chrome/browser/ui/search/search_tab_helper_unittest.cc @@ -190,8 +190,8 @@ TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMatch) { ChromeViewMsg_ChromeIdentityCheckResult::Param params; ChromeViewMsg_ChromeIdentityCheckResult::Read(message, ¶ms); - EXPECT_EQ(test_identity, get<0>(params)); - ASSERT_TRUE(get<1>(params)); + EXPECT_EQ(test_identity, base::get<0>(params)); + ASSERT_TRUE(base::get<1>(params)); } TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMatchSlightlyDifferentGmail) { @@ -213,8 +213,8 @@ TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMatchSlightlyDifferentGmail) { ChromeViewMsg_ChromeIdentityCheckResult::Param params; ChromeViewMsg_ChromeIdentityCheckResult::Read(message, ¶ms); - EXPECT_EQ(test_identity, get<0>(params)); - ASSERT_TRUE(get<1>(params)); + EXPECT_EQ(test_identity, base::get<0>(params)); + ASSERT_TRUE(base::get<1>(params)); } TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMatchSlightlyDifferentGmail2) { @@ -237,8 +237,8 @@ TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMatchSlightlyDifferentGmail2) { ChromeViewMsg_ChromeIdentityCheckResult::Param params; ChromeViewMsg_ChromeIdentityCheckResult::Read(message, ¶ms); - EXPECT_EQ(test_identity, get<0>(params)); - ASSERT_TRUE(get<1>(params)); + EXPECT_EQ(test_identity, base::get<0>(params)); + ASSERT_TRUE(base::get<1>(params)); } TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMismatch) { @@ -257,8 +257,8 @@ TEST_F(SearchTabHelperTest, OnChromeIdentityCheckMismatch) { ChromeViewMsg_ChromeIdentityCheckResult::Param params; ChromeViewMsg_ChromeIdentityCheckResult::Read(message, ¶ms); - EXPECT_EQ(test_identity, get<0>(params)); - ASSERT_FALSE(get<1>(params)); + EXPECT_EQ(test_identity, base::get<0>(params)); + ASSERT_FALSE(base::get<1>(params)); } TEST_F(SearchTabHelperTest, OnChromeIdentityCheckSignedOutMismatch) { @@ -277,8 +277,8 @@ TEST_F(SearchTabHelperTest, OnChromeIdentityCheckSignedOutMismatch) { ChromeViewMsg_ChromeIdentityCheckResult::Param params; ChromeViewMsg_ChromeIdentityCheckResult::Read(message, ¶ms); - EXPECT_EQ(test_identity, get<0>(params)); - ASSERT_FALSE(get<1>(params)); + EXPECT_EQ(test_identity, base::get<0>(params)); + ASSERT_FALSE(base::get<1>(params)); } TEST_F(SearchTabHelperTest, OnHistorySyncCheckSyncing) { @@ -296,7 +296,7 @@ TEST_F(SearchTabHelperTest, OnHistorySyncCheckSyncing) { ChromeViewMsg_HistorySyncCheckResult::Param params; ChromeViewMsg_HistorySyncCheckResult::Read(message, ¶ms); - ASSERT_TRUE(get<0>(params)); + ASSERT_TRUE(base::get<0>(params)); } TEST_F(SearchTabHelperTest, OnHistorySyncCheckNotSyncing) { @@ -314,7 +314,7 @@ TEST_F(SearchTabHelperTest, OnHistorySyncCheckNotSyncing) { ChromeViewMsg_HistorySyncCheckResult::Param params; ChromeViewMsg_HistorySyncCheckResult::Read(message, ¶ms); - ASSERT_FALSE(get<0>(params)); + ASSERT_FALSE(base::get<0>(params)); } class TabTitleObserver : public content::WebContentsObserver { diff --git a/chrome/common/chrome_utility_messages.h b/chrome/common/chrome_utility_messages.h index 1f3c6c0cda06a8..76e7a1c6209d0c 100644 --- a/chrome/common/chrome_utility_messages.h +++ b/chrome/common/chrome_utility_messages.h @@ -33,7 +33,7 @@ #if defined(OS_WIN) // A vector of filters, each being a Tuple containing a display string (i.e. // "Text Files") and a filter pattern (i.e. "*.txt"). -typedef std::vector> +typedef std::vector> GetOpenFileNameFilter; #endif // OS_WIN diff --git a/chrome/renderer/autofill/autofill_renderer_browsertest.cc b/chrome/renderer/autofill/autofill_renderer_browsertest.cc index a8a83017f25770..f8f6bf998b993d 100644 --- a/chrome/renderer/autofill/autofill_renderer_browsertest.cc +++ b/chrome/renderer/autofill/autofill_renderer_browsertest.cc @@ -37,8 +37,8 @@ using blink::WebVector; namespace autofill { -typedef Tuple - AutofillQueryParam; +typedef base::Tuple AutofillQueryParam; class AutofillRendererTest : public ChromeRenderViewTest { public: @@ -86,7 +86,7 @@ TEST_F(AutofillRendererTest, SendForms) { ASSERT_NE(nullptr, message); AutofillHostMsg_FormsSeen::Param params; AutofillHostMsg_FormsSeen::Read(message, ¶ms); - std::vector forms = get<0>(params); + std::vector forms = base::get<0>(params); ASSERT_EQ(1UL, forms.size()); ASSERT_EQ(4UL, forms[0].fields.size()); @@ -149,7 +149,7 @@ TEST_F(AutofillRendererTest, SendForms) { AutofillHostMsg_FormsSeen::ID); ASSERT_NE(nullptr, message); AutofillHostMsg_FormsSeen::Read(message, ¶ms); - forms = get<0>(params); + forms = base::get<0>(params); ASSERT_EQ(1UL, forms.size()); ASSERT_EQ(3UL, forms[0].fields.size()); @@ -181,7 +181,7 @@ TEST_F(AutofillRendererTest, EnsureNoFormSeenIfTooFewFields) { ASSERT_NE(nullptr, message); AutofillHostMsg_FormsSeen::Param params; AutofillHostMsg_FormsSeen::Read(message, ¶ms); - const std::vector& forms = get<0>(params); + const std::vector& forms = base::get<0>(params); ASSERT_EQ(0UL, forms.size()); } @@ -214,7 +214,7 @@ TEST_F(AutofillRendererTest, DynamicallyAddedUnownedFormElements) { ASSERT_NE(nullptr, message); AutofillHostMsg_FormsSeen::Param params; AutofillHostMsg_FormsSeen::Read(message, ¶ms); - std::vector forms = get<0>(params); + std::vector forms = base::get<0>(params); ASSERT_EQ(1UL, forms.size()); ASSERT_EQ(7UL, forms[0].fields.size()); @@ -227,7 +227,7 @@ TEST_F(AutofillRendererTest, DynamicallyAddedUnownedFormElements) { AutofillHostMsg_FormsSeen::ID); ASSERT_NE(nullptr, message); AutofillHostMsg_FormsSeen::Read(message, ¶ms); - forms = get<0>(params); + forms = base::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 378d13dc87eb29..1a88f8d572060f 100644 --- a/chrome/renderer/autofill/form_autocomplete_browsertest.cc +++ b/chrome/renderer/autofill/form_autocomplete_browsertest.cc @@ -38,26 +38,27 @@ void VerifyReceivedRendererMessages(content::MockRenderThread* render_thread, ASSERT_EQ(expect_submitted_message, submitted_message != NULL); // The tuple also includes a timestamp, which is ignored. - Tuple will_submit_forms; + base::Tuple will_submit_forms; AutofillHostMsg_WillSubmitForm::Read(will_submit_message, &will_submit_forms); - ASSERT_EQ(2U, get<0>(will_submit_forms).fields.size()); + ASSERT_EQ(2U, base::get<0>(will_submit_forms).fields.size()); - FormFieldData& will_submit_form_field = get<0>(will_submit_forms).fields[0]; + FormFieldData& will_submit_form_field = + base::get<0>(will_submit_forms).fields[0]; EXPECT_EQ(WebString("fname"), will_submit_form_field.name); EXPECT_EQ(WebString("Rick"), will_submit_form_field.value); - will_submit_form_field = get<0>(will_submit_forms).fields[1]; + will_submit_form_field = base::get<0>(will_submit_forms).fields[1]; EXPECT_EQ(WebString("lname"), will_submit_form_field.name); EXPECT_EQ(WebString("Deckard"), will_submit_form_field.value); if (expect_submitted_message) { - Tuple submitted_forms; + base::Tuple submitted_forms; AutofillHostMsg_FormSubmitted::Read(submitted_message, &submitted_forms); - ASSERT_EQ(2U, get<0>(submitted_forms).fields.size()); + ASSERT_EQ(2U, base::get<0>(submitted_forms).fields.size()); - FormFieldData& submitted_field = get<0>(submitted_forms).fields[0]; + FormFieldData& submitted_field = base::get<0>(submitted_forms).fields[0]; EXPECT_EQ(WebString("fname"), submitted_field.name); EXPECT_EQ(WebString("Rick"), submitted_field.value); - submitted_field = get<0>(submitted_forms).fields[1]; + submitted_field = base::get<0>(submitted_forms).fields[1]; EXPECT_EQ(WebString("lname"), submitted_field.name); EXPECT_EQ(WebString("Deckard"), submitted_field.value); } diff --git a/chrome/renderer/autofill/password_autofill_agent_browsertest.cc b/chrome/renderer/autofill/password_autofill_agent_browsertest.cc index e3b810e3ad6076..e7abb23b38197c 100644 --- a/chrome/renderer/autofill/password_autofill_agent_browsertest.cc +++ b/chrome/renderer/autofill/password_autofill_agent_browsertest.cc @@ -390,12 +390,13 @@ class PasswordAutofillAgentTest : public ChromeRenderViewTest { render_thread_->sink().GetFirstMessageMatching( AutofillHostMsg_ShowPasswordSuggestions::ID); EXPECT_TRUE(message); - Tuple + base::Tuple args; AutofillHostMsg_ShowPasswordSuggestions::Read(message, &args); - EXPECT_EQ(kPasswordFillFormDataId, get<0>(args)); - EXPECT_EQ(ASCIIToUTF16(username), get<2>(args)); - EXPECT_EQ(show_all, static_cast(get<3>(args) & autofill::SHOW_ALL)); + EXPECT_EQ(kPasswordFillFormDataId, base::get<0>(args)); + EXPECT_EQ(ASCIIToUTF16(username), base::get<2>(args)); + EXPECT_EQ(show_all, + static_cast(base::get<3>(args) & autofill::SHOW_ALL)); render_thread_->sink().ClearMessages(); } @@ -408,12 +409,12 @@ class PasswordAutofillAgentTest : public ChromeRenderViewTest { render_thread_->sink().GetFirstMessageMatching( AutofillHostMsg_PasswordFormSubmitted::ID); ASSERT_TRUE(message); - Tuple args; + base::Tuple args; AutofillHostMsg_PasswordFormSubmitted::Read(message, &args); - EXPECT_EQ(ASCIIToUTF16(username_value), get<0>(args).username_value); - EXPECT_EQ(ASCIIToUTF16(password_value), get<0>(args).password_value); + EXPECT_EQ(ASCIIToUTF16(username_value), base::get<0>(args).username_value); + EXPECT_EQ(ASCIIToUTF16(password_value), base::get<0>(args).password_value); EXPECT_EQ(ASCIIToUTF16(new_password_value), - get<0>(args).new_password_value); + base::get<0>(args).new_password_value); } base::string16 username1_; @@ -448,7 +449,7 @@ TEST_F(PasswordAutofillAgentTest, InitialAutocomplete) { AutofillHostMsg_PasswordFormsParsed::ID); ASSERT_TRUE(msg != NULL); - Tuple1 > forms; + base::Tuple1 > forms; AutofillHostMsg_PasswordFormsParsed::Read(msg, &forms); ASSERT_EQ(1U, forms.a.size()); PasswordForm password_form = forms.a[0]; @@ -775,9 +776,9 @@ TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest) { const IPC::Message* message = render_thread_->sink() .GetFirstMessageMatching(AutofillHostMsg_PasswordFormsRendered::ID); EXPECT_TRUE(message); - Tuple, bool> param; + base::Tuple, bool> param; AutofillHostMsg_PasswordFormsRendered::Read(message, ¶m); - EXPECT_TRUE(get<0>(param).size()); + EXPECT_TRUE(base::get<0>(param).size()); render_thread_->sink().ClearMessages(); LoadHTML(kEmptyFormHTML); @@ -785,7 +786,7 @@ TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest) { AutofillHostMsg_PasswordFormsRendered::ID); EXPECT_TRUE(message); AutofillHostMsg_PasswordFormsRendered::Read(message, ¶m); - EXPECT_FALSE(get<0>(param).size()); + EXPECT_FALSE(base::get<0>(param).size()); render_thread_->sink().ClearMessages(); LoadHTML(kNonVisibleFormHTML); @@ -793,7 +794,7 @@ TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest) { AutofillHostMsg_PasswordFormsRendered::ID); EXPECT_TRUE(message); AutofillHostMsg_PasswordFormsRendered::Read(message, ¶m); - EXPECT_FALSE(get<0>(param).size()); + EXPECT_FALSE(base::get<0>(param).size()); } TEST_F(PasswordAutofillAgentTest, SendPasswordFormsTest_Redirection) { diff --git a/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc b/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc index 15c26e310ec03b..e97f3146024370 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, - get<1>(parameters), + base::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(get<2>(read_parameters1), base::UTF8ToUTF16("hello ")); + EXPECT_EQ(base::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(get<2>(read_parameters1), base::UTF8ToUTF16("hello ")); + EXPECT_EQ(base::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(get<2>(read_parameters2), base::UTF8ToUTF16("bye ")); + EXPECT_EQ(base::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 9c534907ec6d50..cd5bd4be72b0bd 100644 --- a/chrome/renderer/translate/translate_helper_browsertest.cc +++ b/chrome/renderer/translate/translate_helper_browsertest.cc @@ -77,15 +77,15 @@ class TranslateHelperBrowserTest : public ChromeRenderViewTest { GetUniqueMessageMatching(ChromeViewHostMsg_PageTranslated::ID); if (!message) return false; - Tuple + base::Tuple translate_param; ChromeViewHostMsg_PageTranslated::Read(message, &translate_param); if (original_lang) - *original_lang = get<0>(translate_param); + *original_lang = base::get<0>(translate_param); if (target_lang) - *target_lang = get<1>(translate_param); + *target_lang = base::get<1>(translate_param); if (error) - *error = get<2>(translate_param); + *error = base::get<2>(translate_param); return true; } @@ -329,7 +329,7 @@ TEST_F(ChromeRenderViewTest, TranslatablePage) { ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Param params; ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_TRUE(get<1>(params)) << "Page should be translatable."; + EXPECT_TRUE(base::get<1>(params)) << "Page should be translatable."; render_thread_->sink().ClearMessages(); // Now the page specifies the META tag to prevent translation. @@ -339,7 +339,7 @@ TEST_F(ChromeRenderViewTest, TranslatablePage) { ChromeViewHostMsg_TranslateLanguageDetermined::ID); ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_FALSE(get<1>(params)) << "Page should not be translatable."; + EXPECT_FALSE(base::get<1>(params)) << "Page should not be translatable."; render_thread_->sink().ClearMessages(); // Try the alternate version of the META tag (content instead of value). @@ -349,7 +349,7 @@ TEST_F(ChromeRenderViewTest, TranslatablePage) { ChromeViewHostMsg_TranslateLanguageDetermined::ID); ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_FALSE(get<1>(params)) << "Page should not be translatable."; + EXPECT_FALSE(base::get<1>(params)) << "Page should not be translatable."; } // Tests that the language meta tag takes precedence over the CLD when reporting @@ -366,7 +366,7 @@ TEST_F(ChromeRenderViewTest, LanguageMetaTag) { ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Param params; ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("es", get<0>(params).adopted_language); + EXPECT_EQ("es", base::get<0>(params).adopted_language); render_thread_->sink().ClearMessages(); // Makes sure we support multiple languages specified. @@ -377,7 +377,7 @@ TEST_F(ChromeRenderViewTest, LanguageMetaTag) { ChromeViewHostMsg_TranslateLanguageDetermined::ID); ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("fr", get<0>(params).adopted_language); + EXPECT_EQ("fr", base::get<0>(params).adopted_language); } // Tests that the language meta tag works even with non-all-lower-case. @@ -394,7 +394,7 @@ TEST_F(ChromeRenderViewTest, LanguageMetaTagCase) { ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Param params; ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("es", get<0>(params).adopted_language); + EXPECT_EQ("es", base::get<0>(params).adopted_language); render_thread_->sink().ClearMessages(); // Makes sure we support multiple languages specified. @@ -405,7 +405,7 @@ TEST_F(ChromeRenderViewTest, LanguageMetaTagCase) { ChromeViewHostMsg_TranslateLanguageDetermined::ID); ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("fr", get<0>(params).adopted_language); + EXPECT_EQ("fr", base::get<0>(params).adopted_language); } // Tests that the language meta tag is converted to Chrome standard of dashes @@ -423,7 +423,7 @@ TEST_F(ChromeRenderViewTest, LanguageCommonMistakesAreCorrected) { ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Param params; ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("en", get<0>(params).adopted_language); + EXPECT_EQ("en", base::get<0>(params).adopted_language); render_thread_->sink().ClearMessages(); LoadHTML("" @@ -432,7 +432,7 @@ TEST_F(ChromeRenderViewTest, LanguageCommonMistakesAreCorrected) { ChromeViewHostMsg_TranslateLanguageDetermined::ID); ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("zh-TW", get<0>(params).adopted_language); + EXPECT_EQ("zh-TW", base::get<0>(params).adopted_language); render_thread_->sink().ClearMessages(); } @@ -446,7 +446,7 @@ TEST_F(ChromeRenderViewTest, BackToTranslatablePage) { ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Param params; ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("zh", get<0>(params).adopted_language); + EXPECT_EQ("zh", base::get<0>(params).adopted_language); render_thread_->sink().ClearMessages(); content::PageState back_state = GetCurrentPageState(); @@ -457,7 +457,7 @@ TEST_F(ChromeRenderViewTest, BackToTranslatablePage) { ChromeViewHostMsg_TranslateLanguageDetermined::ID); ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("fr", get<0>(params).adopted_language); + EXPECT_EQ("fr", base::get<0>(params).adopted_language); render_thread_->sink().ClearMessages(); GoBack(back_state); @@ -466,6 +466,6 @@ TEST_F(ChromeRenderViewTest, BackToTranslatablePage) { ChromeViewHostMsg_TranslateLanguageDetermined::ID); ASSERT_NE(static_cast(NULL), message); ChromeViewHostMsg_TranslateLanguageDetermined::Read(message, ¶ms); - EXPECT_EQ("zh", get<0>(params).adopted_language); + EXPECT_EQ("zh", base::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 6c993f744a0fc8..63f16f4268d79c 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> +typedef std::vector> 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 c37633265f82e3..31ffba8b15d569 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; - Tuple autofill_param; + base::Tuple autofill_param; if (!AutofillMsg_FillForm::Read(message, &autofill_param)) return false; if (page_id) - *page_id = get<0>(autofill_param); + *page_id = base::get<0>(autofill_param); if (results) - *results = get<1>(autofill_param); + *results = base::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; - Tuple autofill_param; + base::Tuple autofill_param; if (!AutofillMsg_PreviewForm::Read(message, &autofill_param)) return false; if (page_id) - *page_id = get<0>(autofill_param); + *page_id = base::get<0>(autofill_param); if (results) - *results = get<1>(autofill_param); + *results = base::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; - Tuple > autofill_param; + base::Tuple > autofill_param; if (!AutofillMsg_FieldTypePredictionsAvailable::Read(message, &autofill_param)) return false; if (predictions) - *predictions = get<0>(autofill_param); + *predictions = base::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; - Tuple autofill_param; + base::Tuple 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 = get<0>(autofill_param); + *value = base::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 f2631453fca5bb..79b66995543c4f 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; - Tuple - autofill_param; + base::Tuple autofill_param; AutofillMsg_RequestAutocompleteResult::Read(message, &autofill_param); - *result = get<0>(autofill_param); + *result = base::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 4b0d116780a1f6..e9fd7fd9e5918e 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; - Tuple param; + base::Tuple param; AutofillHostMsg_RecordSavePasswordProgress::Read(message, ¶m); - *log = get<0>(param); + *log = base::get<0>(param); sink_.ClearMessages(); return true; } diff --git a/components/gcm_driver/gcm_driver_desktop.cc b/components/gcm_driver/gcm_driver_desktop.cc index a31a412be474a2..93c5db36abf6ef 100644 --- a/components/gcm_driver/gcm_driver_desktop.cc +++ b/components/gcm_driver/gcm_driver_desktop.cc @@ -1232,17 +1232,17 @@ void GCMDriverDesktop::GetGCMStatisticsFinished( bool GCMDriverDesktop::TokenTupleComparer::operator()( const TokenTuple& a, const TokenTuple& b) const { - if (get<0>(a) < get<0>(b)) + if (base::get<0>(a) < base::get<0>(b)) return true; - if (get<0>(a) > get<0>(b)) + if (base::get<0>(a) > base::get<0>(b)) return false; - if (get<1>(a) < get<1>(b)) + if (base::get<1>(a) < base::get<1>(b)) return true; - if (get<1>(a) > get<1>(b)) + if (base::get<1>(a) > base::get<1>(b)) return false; - return get<2>(a) < get<2>(b); + return base::get<2>(a) < base::get<2>(b); } } // namespace gcm diff --git a/components/gcm_driver/gcm_driver_desktop.h b/components/gcm_driver/gcm_driver_desktop.h index c21956173fed67..6012a907d0944b 100644 --- a/components/gcm_driver/gcm_driver_desktop.h +++ b/components/gcm_driver/gcm_driver_desktop.h @@ -125,7 +125,7 @@ class GCMDriverDesktop : public GCMDriver, private: class IOWorker; - typedef Tuple TokenTuple; + typedef base::Tuple TokenTuple; struct TokenTupleComparer { bool operator()(const TokenTuple& a, const TokenTuple& b) const; }; diff --git a/components/guest_view/renderer/guest_view_request.cc b/components/guest_view/renderer/guest_view_request.cc index 902429cba5ab77..f666c1c5dc73ac 100644 --- a/components/guest_view/renderer/guest_view_request.cc +++ b/components/guest_view/renderer/guest_view_request.cc @@ -81,7 +81,7 @@ void GuestViewAttachRequest::HandleResponse(const IPC::Message& message) { return; content::RenderView* guest_proxy_render_view = - content::RenderView::FromRoutingID(get<1>(param)); + content::RenderView::FromRoutingID(base::get<1>(param)); // TODO(fsamuel): Should we be reporting an error to JavaScript or DCHECKing? if (!guest_proxy_render_view) return; diff --git a/components/login/base_screen_handler_utils.h b/components/login/base_screen_handler_utils.h index 55497a0d74dce1..3bd1db1c4f8233 100644 --- a/components/login/base_screen_handler_utils.h +++ b/components/login/base_screen_handler_utils.h @@ -70,7 +70,7 @@ typename UnwrapConstRef::Type ParseArg(const base::ListValue* args) { template inline void DispatchToCallback(const base::Callback& callback, const base::ListValue* args, - IndexSequence indexes) { + base::IndexSequence indexes) { DCHECK(args); DCHECK_EQ(sizeof...(Args), args->GetSize()); @@ -80,7 +80,8 @@ inline void DispatchToCallback(const base::Callback& callback, template void CallbackWrapper(const base::Callback& callback, const base::ListValue* args) { - DispatchToCallback(callback, args, MakeIndexSequence()); + DispatchToCallback(callback, args, + base::MakeIndexSequence()); } diff --git a/components/nacl/loader/nacl_ipc_adapter.cc b/components/nacl/loader/nacl_ipc_adapter.cc index e0312a93eea869..8e402e11a00cd2 100644 --- a/components/nacl/loader/nacl_ipc_adapter.cc +++ b/components/nacl/loader/nacl_ipc_adapter.cc @@ -799,7 +799,7 @@ void NaClIPCAdapter::SendMessageOnIOThread(scoped_ptr message) { if (!open_resource_cb_.is_null() && message->type() == PpapiHostMsg_OpenResource::ID && PpapiHostMsg_OpenResource::ReadSendParam(message.get(), &send_params)) { - const std::string key = get<0>(send_params); + const std::string key = base::get<0>(send_params); // Both open_resource_cb_ and SaveOpenResourceMessage must be invoked // from the I/O thread. if (open_resource_cb_.Run( diff --git a/components/password_manager/content/browser/credential_manager_dispatcher_unittest.cc b/components/password_manager/content/browser/credential_manager_dispatcher_unittest.cc index 280b3484a45ce6..56452f49691636 100644 --- a/components/password_manager/content/browser/credential_manager_dispatcher_unittest.cc +++ b/components/password_manager/content/browser/credential_manager_dispatcher_unittest.cc @@ -333,7 +333,7 @@ TEST_F(CredentialManagerDispatcherTest, EXPECT_TRUE(message); CredentialManagerMsg_SendCredential::Param param; CredentialManagerMsg_SendCredential::Read(message, ¶m); - EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(param).type); + EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, base::get<1>(param).type); process()->sink().ClearMessages(); } @@ -361,7 +361,7 @@ TEST_F(CredentialManagerDispatcherTest, EXPECT_TRUE(message); CredentialManagerMsg_SendCredential::Param param; CredentialManagerMsg_SendCredential::Read(message, ¶m); - EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(param).type); + EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, base::get<1>(param).type); process()->sink().ClearMessages(); } @@ -403,7 +403,8 @@ TEST_F( EXPECT_TRUE(message); CredentialManagerMsg_SendCredential::Param send_param; CredentialManagerMsg_SendCredential::Read(message, &send_param); - EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type); + EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, + base::get<1>(send_param).type); } TEST_F(CredentialManagerDispatcherTest, @@ -425,7 +426,8 @@ TEST_F(CredentialManagerDispatcherTest, EXPECT_TRUE(message); CredentialManagerMsg_SendCredential::Param send_param; CredentialManagerMsg_SendCredential::Read(message, &send_param); - EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_LOCAL, get<1>(send_param).type); + EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_LOCAL, + base::get<1>(send_param).type); } TEST_F(CredentialManagerDispatcherTest, @@ -450,7 +452,8 @@ TEST_F(CredentialManagerDispatcherTest, CredentialManagerMsg_SendCredential::Read(message, &send_param); // With two items in the password store, we shouldn't get credentials back. - EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type); + EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, + base::get<1>(send_param).type); } TEST_F(CredentialManagerDispatcherTest, @@ -477,10 +480,12 @@ TEST_F(CredentialManagerDispatcherTest, // We should get |origin_path_form_| back, as |form_| is marked as skipping // zero-click. - EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_LOCAL, get<1>(send_param).type); - EXPECT_EQ(origin_path_form_.username_value, get<1>(send_param).id); - EXPECT_EQ(origin_path_form_.display_name, get<1>(send_param).name); - EXPECT_EQ(origin_path_form_.password_value, get<1>(send_param).password); + EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_LOCAL, + base::get<1>(send_param).type); + EXPECT_EQ(origin_path_form_.username_value, base::get<1>(send_param).id); + EXPECT_EQ(origin_path_form_.display_name, base::get<1>(send_param).name); + EXPECT_EQ(origin_path_form_.password_value, + base::get<1>(send_param).password); } TEST_F(CredentialManagerDispatcherTest, @@ -508,7 +513,8 @@ TEST_F(CredentialManagerDispatcherTest, // We only have cross-origin zero-click credentials; they should not be // returned. - EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type); + EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, + base::get<1>(send_param).type); } TEST_F(CredentialManagerDispatcherTest, @@ -533,7 +539,7 @@ TEST_F(CredentialManagerDispatcherTest, CredentialManagerMsg_RejectCredentialRequest::Param reject_param; CredentialManagerMsg_RejectCredentialRequest::Read(message, &reject_param); EXPECT_EQ(blink::WebCredentialManagerError::ErrorTypePendingRequest, - get<1>(reject_param)); + base::get<1>(reject_param)); EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _)) .Times(testing::Exactly(1)); EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0)); @@ -549,7 +555,8 @@ TEST_F(CredentialManagerDispatcherTest, EXPECT_TRUE(message); CredentialManagerMsg_SendCredential::Param send_param; CredentialManagerMsg_SendCredential::Read(message, &send_param); - EXPECT_NE(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type); + EXPECT_NE(CredentialType::CREDENTIAL_TYPE_EMPTY, + base::get<1>(send_param).type); process()->sink().ClearMessages(); } @@ -616,7 +623,7 @@ TEST_F(CredentialManagerDispatcherTest, IncognitoZeroClickRequestCredential) { ASSERT_TRUE(message); CredentialManagerMsg_SendCredential::Param param; CredentialManagerMsg_SendCredential::Read(message, ¶m); - EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(param).type); + EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, base::get<1>(param).type); } } // namespace password_manager 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 fe1c092c809445..443a25acb9cad3 100644 --- a/components/password_manager/content/renderer/credential_manager_client_browsertest.cc +++ b/components/password_manager/content/renderer/credential_manager_client_browsertest.cc @@ -62,30 +62,30 @@ class MAYBE_CredentialManagerClientTest : public content::RenderViewTest { switch (message_id) { case CredentialManagerHostMsg_NotifyFailedSignIn::ID: { - Tuple param; + base::Tuple param; CredentialManagerHostMsg_NotifyFailedSignIn::Read(message, ¶m); - request_id = get<0>(param); + request_id = base::get<0>(param); break; } case CredentialManagerHostMsg_NotifySignedIn::ID: { - Tuple param; + base::Tuple param; CredentialManagerHostMsg_NotifySignedIn::Read(message, ¶m); - request_id = get<0>(param); + request_id = base::get<0>(param); break; } case CredentialManagerHostMsg_NotifySignedOut::ID: { - Tuple param; + base::Tuple param; CredentialManagerHostMsg_NotifySignedOut::Read(message, ¶m); - request_id = get<0>(param); + request_id = base::get<0>(param); break; } case CredentialManagerHostMsg_RequestCredential::ID: { - Tuple> param; + base::Tuple> param; CredentialManagerHostMsg_RequestCredential::Read(message, ¶m); - request_id = get<0>(param); + request_id = base::get<0>(param); break; } diff --git a/components/printing/test/print_web_view_helper_browsertest.cc b/components/printing/test/print_web_view_helper_browsertest.cc index 864adc63d475c2..21ebc5a399007b 100644 --- a/components/printing/test/print_web_view_helper_browsertest.cc +++ b/components/printing/test/print_web_view_helper_browsertest.cc @@ -172,7 +172,7 @@ class PrintWebViewHelperTestBase : public content::RenderViewTest { PrintHostMsg_DidGetPrintedPagesCount::Param post_page_count_param; PrintHostMsg_DidGetPrintedPagesCount::Read(page_cnt_msg, &post_page_count_param); - EXPECT_EQ(count, get<1>(post_page_count_param)); + EXPECT_EQ(count, base::get<1>(post_page_count_param)); #endif // defined(OS_CHROMEOS) } @@ -187,7 +187,7 @@ class PrintWebViewHelperTestBase : public content::RenderViewTest { PrintHostMsg_DidGetPreviewPageCount::Param post_page_count_param; PrintHostMsg_DidGetPreviewPageCount::Read(page_cnt_msg, &post_page_count_param); - EXPECT_EQ(count, get<0>(post_page_count_param).page_count); + EXPECT_EQ(count, base::get<0>(post_page_count_param).page_count); } // Verifies whether the pages printed or not. @@ -206,7 +206,7 @@ class PrintWebViewHelperTestBase : public content::RenderViewTest { if (printed) { PrintHostMsg_DidPrintPage::Param post_did_print_page_param; PrintHostMsg_DidPrintPage::Read(print_msg, &post_did_print_page_param); - EXPECT_EQ(0, get<0>(post_did_print_page_param).page_number); + EXPECT_EQ(0, base::get<0>(post_did_print_page_param).page_number); } #endif // defined(OS_CHROMEOS) } @@ -543,9 +543,9 @@ class MAYBE_PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase { if (did_get_preview_msg) { PrintHostMsg_MetafileReadyForPrinting::Param preview_param; PrintHostMsg_MetafileReadyForPrinting::Read(preview_msg, &preview_param); - 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); + EXPECT_NE(0, base::get<0>(preview_param).document_cookie); + EXPECT_NE(0, base::get<0>(preview_param).expected_pages_count); + EXPECT_NE(0U, base::get<0>(preview_param).data_size); } } @@ -571,12 +571,12 @@ class MAYBE_PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase { if (msg->type() == PrintHostMsg_DidPreviewPage::ID) { PrintHostMsg_DidPreviewPage::Param page_param; PrintHostMsg_DidPreviewPage::Read(msg, &page_param); - if (get<0>(page_param).page_number == page_number) { + if (base::get<0>(page_param).page_number == page_number) { msg_found = true; if (generate_draft_pages) - EXPECT_NE(0U, get<0>(page_param).data_size); + EXPECT_NE(0U, base::get<0>(page_param).data_size); else - EXPECT_EQ(0U, get<0>(page_param).data_size); + EXPECT_EQ(0U, base::get<0>(page_param).data_size); break; } } @@ -599,13 +599,13 @@ class MAYBE_PrintWebViewHelperPreviewTest : public PrintWebViewHelperTestBase { PrintHostMsg_DidGetDefaultPageLayout::Param param; PrintHostMsg_DidGetDefaultPageLayout::Read(default_page_layout_msg, ¶m); - 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)); + EXPECT_EQ(content_width, base::get<0>(param).content_width); + EXPECT_EQ(content_height, base::get<0>(param).content_height); + EXPECT_EQ(margin_top, base::get<0>(param).margin_top); + EXPECT_EQ(margin_right, base::get<0>(param).margin_right); + EXPECT_EQ(margin_left, base::get<0>(param).margin_left); + EXPECT_EQ(margin_bottom, base::get<0>(param).margin_bottom); + EXPECT_EQ(page_has_print_css, base::get<2>(param)); } } diff --git a/content/browser/devtools/render_frame_devtools_agent_host.cc b/content/browser/devtools/render_frame_devtools_agent_host.cc index 1ff137d500b91d..bac8a6b3525e8a 100644 --- a/content/browser/devtools/render_frame_devtools_agent_host.cc +++ b/content/browser/devtools/render_frame_devtools_agent_host.cc @@ -530,12 +530,12 @@ void RenderFrameDevToolsAgentHost::OnSwapCompositorFrame( if (!ViewHostMsg_SwapCompositorFrame::Read(&message, ¶m)) return; if (page_handler_) - page_handler_->OnSwapCompositorFrame(get<1>(param).metadata); + page_handler_->OnSwapCompositorFrame(base::get<1>(param).metadata); if (input_handler_) - input_handler_->OnSwapCompositorFrame(get<1>(param).metadata); + input_handler_->OnSwapCompositorFrame(base::get<1>(param).metadata); if (frame_trace_recorder_) { frame_trace_recorder_->OnSwapCompositorFrame( - render_frame_host_, get<1>(param).metadata); + render_frame_host_, base::get<1>(param).metadata); } } diff --git a/content/browser/frame_host/navigation_controller_impl_unittest.cc b/content/browser/frame_host/navigation_controller_impl_unittest.cc index baf63d6863a2fd..13d5bf40f4bb59 100644 --- a/content/browser/frame_host/navigation_controller_impl_unittest.cc +++ b/content/browser/frame_host/navigation_controller_impl_unittest.cc @@ -237,12 +237,12 @@ class NavigationControllerTest return navigation_request->common_params().url; } const IPC::Message* message = - process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID); + process()->sink().GetFirstMessageMatching(FrameMsg_Navigate::ID); CHECK(message); - Tuple nav_params; FrameMsg_Navigate::Read(message, &nav_params); - return get<0>(nav_params).url; + return base::get<0>(nav_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 ea06cd10711cda..2332cbf490fd52 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, ¶m); - return get<2>(param); + return base::get<2>(param); } template @@ -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, ¶m)); - EXPECT_EQ(arg1, get<0>(param)); + EXPECT_EQ(arg1, base::get<0>(param)); } template @@ -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, ¶m)); - EXPECT_EQ(arg1, get<0>(param)); - EXPECT_EQ(arg2, get<1>(param)); + EXPECT_EQ(arg1, base::get<0>(param)); + EXPECT_EQ(arg2, base::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 3324d236f26ee6..b6d5f991b3a998 100644 --- a/content/browser/renderer_host/input/touch_input_browsertest.cc +++ b/content/browser/renderer_host/input/touch_input_browsertest.cc @@ -117,8 +117,8 @@ class InputEventMessageFilter : public BrowserMessageFilter { if (message.type() == InputHostMsg_HandleInputEvent_ACK::ID) { InputHostMsg_HandleInputEvent_ACK::Param params; InputHostMsg_HandleInputEvent_ACK::Read(&message, ¶ms); - WebInputEvent::Type type = get<0>(params).type; - InputEventAckState ack = get<0>(params).state; + WebInputEvent::Type type = base::get<0>(params).type; + InputEventAckState ack = base::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 c420942016967c..fa179b8c7a4aa7 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); - Tuple error_in_message; + base::Tuple error_in_message; WebRTCIdentityHostMsg_RequestFailed::Read(&ipc, &error_in_message); - EXPECT_EQ(FAKE_SEQUENCE_NUMBER, get<0>(error_in_message)); - EXPECT_EQ(error, get<1>(error_in_message)); + EXPECT_EQ(FAKE_SEQUENCE_NUMBER, base::get<0>(error_in_message)); + EXPECT_EQ(error, base::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); - Tuple identity_in_message; + base::Tuple identity_in_message; WebRTCIdentityHostMsg_IdentityReady::Read(&ipc, &identity_in_message); - 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)); + EXPECT_EQ(FAKE_SEQUENCE_NUMBER, base::get<0>(identity_in_message)); + EXPECT_EQ(cert, base::get<1>(identity_in_message)); + EXPECT_EQ(key, base::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 9ab463407056a8..76358d2fa4b981 100644 --- a/content/browser/renderer_host/p2p/socket_host_test_utils.h +++ b/content/browser/renderer_host/p2p/socket_host_test_utils.h @@ -106,7 +106,7 @@ MATCHER_P(MatchPacketMessage, packet_content, "") { return false; P2PMsg_OnDataReceived::Param params; P2PMsg_OnDataReceived::Read(arg, ¶ms); - return get<2>(params) == packet_content; + return base::get<2>(params) == packet_content; } MATCHER_P(MatchIncomingSocketMessage, address, "") { @@ -115,7 +115,7 @@ MATCHER_P(MatchIncomingSocketMessage, address, "") { P2PMsg_OnIncomingTcpConnection::Param params; P2PMsg_OnIncomingTcpConnection::Read( arg, ¶ms); - return get<1>(params) == address; + return base::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 de06ef321a9eb6..e61f75f4a76bbf 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 = get<0>(reply_msg_param); + PP_PrintSettings_Dev actual_settings = base::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 41245f2d80a965..8a9e86362037e8 100644 --- a/content/browser/renderer_host/render_widget_host_impl.cc +++ b/content/browser/renderer_host/render_widget_host_impl.cc @@ -1458,10 +1458,10 @@ bool RenderWidgetHostImpl::OnSwapCompositorFrame( if (!ViewHostMsg_SwapCompositorFrame::Read(&message, ¶m)) return false; scoped_ptr frame(new cc::CompositorFrame); - uint32 output_surface_id = get<0>(param); - get<1>(param).AssignTo(frame.get()); + uint32 output_surface_id = base::get<0>(param); + base::get<1>(param).AssignTo(frame.get()); std::vector messages_to_deliver_with_frame; - messages_to_deliver_with_frame.swap(get<2>(param)); + messages_to_deliver_with_frame.swap(base::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 f980a89296206c..ad581ac10aea38 100644 --- a/content/browser/renderer_host/render_widget_host_unittest.cc +++ b/content/browser/renderer_host/render_widget_host_unittest.cc @@ -815,9 +815,9 @@ TEST_F(RenderWidgetHostTest, Background) { process_->sink().GetUniqueMessageMatching( ViewMsg_SetBackgroundOpaque::ID); ASSERT_TRUE(set_background); - Tuple sent_background; + base::Tuple sent_background; ViewMsg_SetBackgroundOpaque::Read(set_background, &sent_background); - EXPECT_FALSE(get<0>(sent_background)); + EXPECT_FALSE(base::get<0>(sent_background)); #if defined(USE_AURA) // See the comment above |InitAsChild(NULL)|. @@ -852,9 +852,9 @@ TEST_F(RenderWidgetHostTest, HiddenPaint) { const IPC::Message* restored = process_->sink().GetUniqueMessageMatching( ViewMsg_WasShown::ID); ASSERT_TRUE(restored); - Tuple needs_repaint; + base::Tuple needs_repaint; ViewMsg_WasShown::Read(restored, &needs_repaint); - EXPECT_TRUE(get<0>(needs_repaint)); + EXPECT_TRUE(base::get<0>(needs_repaint)); } TEST_F(RenderWidgetHostTest, IgnoreKeyEventsHandledByRenderer) { @@ -1094,7 +1094,7 @@ std::string GetInputMessageTypes(RenderWidgetHostProcess* process) { EXPECT_EQ(InputMsg_HandleInputEvent::ID, message->type()); InputMsg_HandleInputEvent::Param params; EXPECT_TRUE(InputMsg_HandleInputEvent::Read(message, ¶ms)); - const WebInputEvent* event = get<0>(params); + const WebInputEvent* event = base::get<0>(params); if (i != 0) result += " "; result += WebInputEventTraits::GetName(event->type); @@ -1420,7 +1420,7 @@ ui::LatencyInfo GetLatencyInfoFromInputEvent(RenderWidgetHostProcess* process) { InputMsg_HandleInputEvent::Param params; EXPECT_TRUE(InputMsg_HandleInputEvent::Read(message, ¶ms)); process->sink().ClearMessages(); - return get<1>(params); + return base::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 0d4b114830fda3..78f9bd925c784b 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 @@ -478,10 +478,11 @@ class RenderWidgetHostViewAuraTest : public testing::Test { return; } - if (!WebInputEventTraits::WillReceiveAckFromRenderer(*get<0>(params))) + if (!WebInputEventTraits::WillReceiveAckFromRenderer( + *base::get<0>(params))) return; - const blink::WebInputEvent* event = get<0>(params); + const blink::WebInputEvent* event = base::get<0>(params); SendTouchEventACK(event->type, ack_result, WebInputEventTraits::GetUniqueTouchEventId(*event)); } @@ -969,20 +970,21 @@ TEST_F(RenderWidgetHostViewAuraTest, SetCompositionText) { InputMsg_ImeSetComposition::Param params; InputMsg_ImeSetComposition::Read(msg, ¶ms); // composition text - EXPECT_EQ(composition_text.text, get<0>(params)); + EXPECT_EQ(composition_text.text, base::get<0>(params)); // underlines - ASSERT_EQ(underlines.size(), get<1>(params).size()); + ASSERT_EQ(underlines.size(), base::get<1>(params).size()); for (size_t i = 0; i < underlines.size(); ++i) { - 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].start_offset, + base::get<1>(params)[i].startOffset); + EXPECT_EQ(underlines[i].end_offset, base::get<1>(params)[i].endOffset); + EXPECT_EQ(underlines[i].color, base::get<1>(params)[i].color); + EXPECT_EQ(underlines[i].thick, base::get<1>(params)[i].thick); EXPECT_EQ(underlines[i].background_color, - get<1>(params)[i].backgroundColor); + base::get<1>(params)[i].backgroundColor); } // highlighted range - 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"; + EXPECT_EQ(4, base::get<2>(params)) << "Should be the same to the caret pos"; + EXPECT_EQ(4, base::get<3>(params)) << "Should be the same to the caret pos"; } view_->ImeCancelComposition(); @@ -1289,9 +1291,9 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) { EXPECT_EQ(ViewMsg_Resize::ID, msg->type()); ViewMsg_Resize::Param params; ViewMsg_Resize::Read(msg, ¶ms); - EXPECT_EQ("100x100", get<0>(params).new_size.ToString()); // dip size + EXPECT_EQ("100x100", base::get<0>(params).new_size.ToString()); // dip size EXPECT_EQ("100x100", - get<0>(params).physical_backing_size.ToString()); // backing size + base::get<0>(params).physical_backing_size.ToString()); // backing size } widget_host_->ResetSizeAndRepaintPendingFlags(); @@ -1306,10 +1308,10 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) { EXPECT_EQ(ViewMsg_Resize::ID, msg->type()); ViewMsg_Resize::Param params; ViewMsg_Resize::Read(msg, ¶ms); - EXPECT_EQ(2.0f, get<0>(params).screen_info.deviceScaleFactor); - EXPECT_EQ("100x100", get<0>(params).new_size.ToString()); // dip size + EXPECT_EQ(2.0f, base::get<0>(params).screen_info.deviceScaleFactor); + EXPECT_EQ("100x100", base::get<0>(params).new_size.ToString()); // dip size EXPECT_EQ("200x200", - get<0>(params).physical_backing_size.ToString()); // backing size + base::get<0>(params).physical_backing_size.ToString()); // backing size } widget_host_->ResetSizeAndRepaintPendingFlags(); @@ -1324,10 +1326,10 @@ TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) { EXPECT_EQ(ViewMsg_Resize::ID, msg->type()); ViewMsg_Resize::Param params; ViewMsg_Resize::Read(msg, ¶ms); - EXPECT_EQ(1.0f, get<0>(params).screen_info.deviceScaleFactor); - EXPECT_EQ("100x100", get<0>(params).new_size.ToString()); // dip size + EXPECT_EQ(1.0f, base::get<0>(params).screen_info.deviceScaleFactor); + EXPECT_EQ("100x100", base::get<0>(params).new_size.ToString()); // dip size EXPECT_EQ("100x100", - get<0>(params).physical_backing_size.ToString()); // backing size + base::get<0>(params).physical_backing_size.ToString()); // backing size } } @@ -1492,14 +1494,16 @@ TEST_F(RenderWidgetHostViewAuraTest, DISABLED_FullscreenResize) { ViewMsg_Resize::Param params; ViewMsg_Resize::Read(msg, ¶ms); EXPECT_EQ("0,0 800x600", - gfx::Rect(get<0>(params).screen_info.availableRect).ToString()); - EXPECT_EQ("800x600", get<0>(params).new_size.ToString()); + gfx::Rect( + base::get<0>(params).screen_info.availableRect).ToString()); + EXPECT_EQ("800x600", base::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, get<0>(params).new_size, gfx::Rect(get<0>(params).new_size))); + 1.f, base::get<0>(params).new_size, + gfx::Rect(base::get<0>(params).new_size))); ui::DrawWaiterForTest::WaitForCommit( root_window->GetHost()->compositor()); } @@ -1517,12 +1521,14 @@ TEST_F(RenderWidgetHostViewAuraTest, DISABLED_FullscreenResize) { ViewMsg_Resize::Param params; ViewMsg_Resize::Read(msg, ¶ms); EXPECT_EQ("0,0 1600x1200", - gfx::Rect(get<0>(params).screen_info.availableRect).ToString()); - EXPECT_EQ("1600x1200", get<0>(params).new_size.ToString()); + gfx::Rect( + base::get<0>(params).screen_info.availableRect).ToString()); + EXPECT_EQ("1600x1200", base::get<0>(params).new_size.ToString()); view_->OnSwapCompositorFrame( 0, MakeDelegatedFrame( - 1.f, get<0>(params).new_size, gfx::Rect(get<0>(params).new_size))); + 1.f, base::get<0>(params).new_size, + gfx::Rect(base::get<0>(params).new_size))); ui::DrawWaiterForTest::WaitForCommit( root_window->GetHost()->compositor()); } @@ -1621,7 +1627,7 @@ TEST_F(RenderWidgetHostViewAuraTest, Resize) { EXPECT_EQ(ViewMsg_Resize::ID, msg->type()); ViewMsg_Resize::Param params; ViewMsg_Resize::Read(msg, ¶ms); - EXPECT_EQ(size2.ToString(), get<0>(params).new_size.ToString()); + EXPECT_EQ(size2.ToString(), base::get<0>(params).new_size.ToString()); } // Send resize ack to observe new Resize messages. update_params.view_size = size2; @@ -1676,7 +1682,7 @@ TEST_F(RenderWidgetHostViewAuraTest, Resize) { // to this extra IPC coming in. InputMsg_HandleInputEvent::Param params; InputMsg_HandleInputEvent::Read(msg, ¶ms); - const blink::WebInputEvent* event = get<0>(params); + const blink::WebInputEvent* event = base::get<0>(params); EXPECT_EQ(blink::WebInputEvent::MouseMove, event->type); break; } @@ -1686,7 +1692,7 @@ TEST_F(RenderWidgetHostViewAuraTest, Resize) { EXPECT_FALSE(has_resize); ViewMsg_Resize::Param params; ViewMsg_Resize::Read(msg, ¶ms); - EXPECT_EQ(size3.ToString(), get<0>(params).new_size.ToString()); + EXPECT_EQ(size3.ToString(), base::get<0>(params).new_size.ToString()); has_resize = true; break; } @@ -2373,7 +2379,7 @@ TEST_F(RenderWidgetHostViewAuraTest, VisibleViewportTest) { ViewMsg_Resize::Param params; ViewMsg_Resize::Read(message, ¶ms); - EXPECT_EQ(60, get<0>(params).visible_viewport_size.height()); + EXPECT_EQ(60, base::get<0>(params).visible_viewport_size.height()); } // Ensures that touch event positions are never truncated to integers. @@ -3500,7 +3506,7 @@ TEST_F(RenderWidgetHostViewAuraTest, SurfaceIdNamespaceInitialized) { view_->SetSize(size); view_->OnSwapCompositorFrame(0, MakeDelegatedFrame(1.f, size, gfx::Rect(size))); - EXPECT_EQ(view_->GetSurfaceIdNamespace(), get<0>(params)); + EXPECT_EQ(view_->GetSurfaceIdNamespace(), base::get<0>(params)); } } // namespace content diff --git a/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm b/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm index f522680d582fb2..772b6c0505e32b 100644 --- a/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm +++ b/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm @@ -847,9 +847,9 @@ InputEventAck unhandled_ack(blink::WebInputEvent::MouseWheel, set_background = process_host->sink().GetUniqueMessageMatching( ViewMsg_SetBackgroundOpaque::ID); ASSERT_TRUE(set_background); - Tuple sent_background; + base::Tuple sent_background; ViewMsg_SetBackgroundOpaque::Read(set_background, &sent_background); - EXPECT_FALSE(get<0>(sent_background)); + EXPECT_FALSE(base::get<0>(sent_background)); // Try setting it back. process_host->sink().ClearMessages(); @@ -860,7 +860,7 @@ InputEventAck unhandled_ack(blink::WebInputEvent::MouseWheel, ViewMsg_SetBackgroundOpaque::ID); ASSERT_TRUE(set_background); ViewMsg_SetBackgroundOpaque::Read(set_background, &sent_background); - EXPECT_TRUE(get<0>(sent_background)); + EXPECT_TRUE(base::get<0>(sent_background)); host->Shutdown(); } @@ -885,9 +885,9 @@ bool ZoomDisabledForPinchUpdateMessage() { break; } DCHECK(message); - Tuple data; + base::Tuple data; InputMsg_HandleInputEvent::Read(message, &data); - IPC::WebInputEventPointer ipc_event = get<0>(data); + IPC::WebInputEventPointer ipc_event = base::get<0>(data); const blink::WebGestureEvent* gesture_event = static_cast(ipc_event); return gesture_event->data.pinchUpdate.zoomDisabled; diff --git a/content/browser/resolve_proxy_msg_helper_unittest.cc b/content/browser/resolve_proxy_msg_helper_unittest.cc index c03545c47e76db..9dab2939cdf458 100644 --- a/content/browser/resolve_proxy_msg_helper_unittest.cc +++ b/content/browser/resolve_proxy_msg_helper_unittest.cc @@ -89,11 +89,12 @@ class ResolveProxyMsgHelperTest : public testing::Test, public IPC::Listener { private: bool OnMessageReceived(const IPC::Message& msg) override { - TupleTypes::ValueTuple reply_data; + base::TupleTypes::ValueTuple + reply_data; EXPECT_TRUE(ViewHostMsg_ResolveProxy::ReadReplyParam(&msg, &reply_data)); DCHECK(!pending_result_.get()); pending_result_.reset( - new PendingResult(get<0>(reply_data), get<1>(reply_data))); + new PendingResult(base::get<0>(reply_data), base::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 375f6170d82c76..9daf395ca14d53 100644 --- a/content/browser/service_worker/service_worker_handle_unittest.cc +++ b/content/browser/service_worker/service_worker_handle_unittest.cc @@ -35,8 +35,8 @@ void VerifyStateChangedMessage(int expected_handle_id, ServiceWorkerMsg_ServiceWorkerStateChanged::Param param; ASSERT_TRUE(ServiceWorkerMsg_ServiceWorkerStateChanged::Read( message, ¶m)); - EXPECT_EQ(expected_handle_id, get<1>(param)); - EXPECT_EQ(expected_state, get<2>(param)); + EXPECT_EQ(expected_handle_id, base::get<1>(param)); + EXPECT_EQ(expected_state, base::get<2>(param)); } } // namespace diff --git a/content/browser/service_worker/service_worker_version.cc b/content/browser/service_worker/service_worker_version.cc index d52e4cd2fbcb41..924c55be239d9d 100644 --- a/content/browser/service_worker/service_worker_version.cc +++ b/content/browser/service_worker/service_worker_version.cc @@ -294,15 +294,15 @@ base::TimeDelta GetTickDuration(const base::TimeTicks& time) { void OnGetWindowClientsFromUI( // The tuple contains process_id, frame_id, client_uuid. - const std::vector>& clients_info, + const std::vector>& clients_info, const GURL& script_url, const GetClientsCallback& callback) { scoped_ptr clients(new ServiceWorkerClients); for (const auto& it : clients_info) { ServiceWorkerClientInfo info = - ServiceWorkerProviderHost::GetWindowClientInfoOnUI(get<0>(it), - get<1>(it)); + ServiceWorkerProviderHost::GetWindowClientInfoOnUI(base::get<0>(it), + base::get<1>(it)); // If the request to the provider_host returned an empty // ServiceWorkerClientInfo, that means that it wasn't possible to associate @@ -317,7 +317,7 @@ void OnGetWindowClientsFromUI( if (info.url.GetOrigin() != script_url.GetOrigin()) continue; - info.client_uuid = get<2>(it); + info.client_uuid = base::get<2>(it); clients->push_back(info); } @@ -325,12 +325,13 @@ void OnGetWindowClientsFromUI( base::Bind(callback, base::Passed(&clients))); } -void AddWindowClient(ServiceWorkerProviderHost* host, - std::vector>* client_info) { +void AddWindowClient( + ServiceWorkerProviderHost* host, + std::vector>* client_info) { if (host->client_type() != blink::WebServiceWorkerClientTypeWindow) return; - client_info->push_back( - MakeTuple(host->process_id(), host->frame_id(), host->client_uuid())); + client_info->push_back(base::MakeTuple(host->process_id(), host->frame_id(), + host->client_uuid())); } void AddNonWindowClient(ServiceWorkerProviderHost* host, @@ -1729,7 +1730,7 @@ void ServiceWorkerVersion::GetWindowClients( const ServiceWorkerClientQueryOptions& options) { DCHECK(options.client_type == blink::WebServiceWorkerClientTypeWindow || options.client_type == blink::WebServiceWorkerClientTypeAll); - std::vector> clients_info; + std::vector> clients_info; if (!options.include_uncontrolled) { for (auto& controllee : controllee_map_) AddWindowClient(controllee.second, &clients_info); diff --git a/content/browser/shared_worker/shared_worker_host.cc b/content/browser/shared_worker/shared_worker_host.cc index d9b6d9fb104818..e28687ed9350fa 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, ¶m)) return; - int sent_message_port_id = get<0>(param); - int new_routing_id = get<1>(param); + int sent_message_port_id = base::get<0>(param); + int new_routing_id = base::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 7ca585ea2cd531..70dde1d3ec42f2 100644 --- a/content/browser/shared_worker/shared_worker_service_impl_unittest.cc +++ b/content/browser/shared_worker/shared_worker_service_impl_unittest.cc @@ -327,12 +327,13 @@ void CheckWorkerProcessMsgCreateWorker( int* route_id) { scoped_ptr msg(renderer_host->PopMessage()); EXPECT_EQ(WorkerProcessMsg_CreateWorker::ID, msg->type()); - Tuple param; + base::Tuple param; EXPECT_TRUE(WorkerProcessMsg_CreateWorker::Read(msg.get(), ¶m)); - 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; + EXPECT_EQ(GURL(expected_url), base::get<0>(param).url); + EXPECT_EQ(base::ASCIIToUTF16(expected_name), base::get<0>(param).name); + EXPECT_EQ(expected_security_policy_type, + base::get<0>(param).security_policy_type); + *route_id = base::get<0>(param).route_id; } void CheckViewMsgWorkerCreated(MockRendererProcessHost* renderer_host, @@ -358,8 +359,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(), ¶ms)); - int port_id = get<0>(params); - *routing_id = get<1>(params); + int port_id = base::get<0>(params); + *routing_id = base::get<1>(params); EXPECT_EQ(expected_sent_message_port_id, port_id); } @@ -371,7 +372,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(), ¶ms)); - base::string16 data = get<0>(params).message_as_string; + base::string16 data = base::get<0>(params).message_as_string; 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 a715b464000ec3..ccd1689d3a57dc 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, ¶ms); - blink::WebInputEvent::Type type = get<0>(params).type; - InputEventAckState ack = get<0>(params).state; + blink::WebInputEvent::Type type = base::get<0>(params).type; + InputEventAckState ack = base::get<0>(params).state; BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(&InputEventMessageFilterWaitsForAcks::ReceivedEventAck, this, type, ack)); diff --git a/content/child/fileapi/webfilesystem_impl.cc b/content/child/fileapi/webfilesystem_impl.cc index f724271aa67f71..9aba73447a2c73 100644 --- a/content/child/fileapi/webfilesystem_impl.cc +++ b/content/child/fileapi/webfilesystem_impl.cc @@ -25,6 +25,7 @@ #include "third_party/WebKit/public/web/WebHeap.h" #include "url/gurl.h" +using base::MakeTuple; using blink::WebFileInfo; using blink::WebFileSystemCallbacks; using blink::WebFileSystemEntry; diff --git a/content/child/resource_dispatcher_unittest.cc b/content/child/resource_dispatcher_unittest.cc index e0938d1aad6c14..bd5e13d648a7ba 100644 --- a/content/child/resource_dispatcher_unittest.cc +++ b/content/child/resource_dispatcher_unittest.cc @@ -186,60 +186,60 @@ class ResourceDispatcherTest : public testing::Test, public IPC::Sender { ADD_FAILURE() << "Expected ResourceHostMsg_RequestResource message"; return -1; } - ResourceHostMsg_Request request = get<2>(params); + ResourceHostMsg_Request request = base::get<2>(params); EXPECT_EQ(kTestPageUrl, request.url.spec()); message_queue_.erase(message_queue_.begin()); - return get<1>(params); + return base::get<1>(params); } void ConsumeFollowRedirect(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); - Tuple args; + base::Tuple args; ASSERT_EQ(ResourceHostMsg_FollowRedirect::ID, message_queue_[0].type()); ASSERT_TRUE(ResourceHostMsg_FollowRedirect::Read( &message_queue_[0], &args)); - EXPECT_EQ(expected_request_id, get<0>(args)); + EXPECT_EQ(expected_request_id, base::get<0>(args)); message_queue_.erase(message_queue_.begin()); } void ConsumeDataReceived_ACK(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); - Tuple args; + base::Tuple 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, get<0>(args)); + EXPECT_EQ(expected_request_id, base::get<0>(args)); message_queue_.erase(message_queue_.begin()); } void ConsumeDataDownloaded_ACK(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); - Tuple args; + base::Tuple 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, get<0>(args)); + EXPECT_EQ(expected_request_id, base::get<0>(args)); message_queue_.erase(message_queue_.begin()); } void ConsumeReleaseDownloadedFile(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); - Tuple args; + base::Tuple args; ASSERT_EQ(ResourceHostMsg_ReleaseDownloadedFile::ID, message_queue_[0].type()); ASSERT_TRUE(ResourceHostMsg_ReleaseDownloadedFile::Read( &message_queue_[0], &args)); - EXPECT_EQ(expected_request_id, get<0>(args)); + EXPECT_EQ(expected_request_id, base::get<0>(args)); message_queue_.erase(message_queue_.begin()); } void ConsumeCancelRequest(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); - Tuple args; + base::Tuple args; ASSERT_EQ(ResourceHostMsg_CancelRequest::ID, message_queue_[0].type()); ASSERT_TRUE(ResourceHostMsg_CancelRequest::Read( &message_queue_[0], &args)); - EXPECT_EQ(expected_request_id, get<0>(args)); + EXPECT_EQ(expected_request_id, base::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 5e0fe9702c0299..4dbcb38779562b 100644 --- a/content/child/threaded_data_provider.cc +++ b/content/child/threaded_data_provider.cc @@ -97,7 +97,8 @@ bool DataProviderMessageFilter::OnMessageReceived( if (request_id == request_id_) { ResourceMsg_DataReceived::Schema::Param arg; if (ResourceMsg_DataReceived::Read(&message, &arg)) { - OnReceivedData(get<0>(arg), get<1>(arg), get<2>(arg), get<3>(arg)); + OnReceivedData(base::get<0>(arg), base::get<1>(arg), + base::get<2>(arg), base::get<3>(arg)); return true; } } diff --git a/content/common/gpu/gpu_channel.cc b/content/common/gpu/gpu_channel.cc index 2768eea2f41d39..017a151de9a149 100644 --- a/content/common/gpu/gpu_channel.cc +++ b/content/common/gpu/gpu_channel.cc @@ -112,7 +112,7 @@ class GpuChannelMessageFilter : public IPC::MessageFilter { } if (message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) { - Tuple retire; + base::Tuple retire; IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message); if (!GpuCommandBufferMsg_InsertSyncPoint::ReadSendParam(&message, &retire)) { @@ -120,7 +120,7 @@ class GpuChannelMessageFilter : public IPC::MessageFilter { Send(reply); return true; } - if (!future_sync_points_ && !get<0>(retire)) { + if (!future_sync_points_ && !base::get<0>(retire)) { LOG(ERROR) << "Untrusted contexts can't create future sync points"; reply->set_reply_error(); Send(reply); @@ -133,7 +133,7 @@ class GpuChannelMessageFilter : public IPC::MessageFilter { FROM_HERE, base::Bind(&GpuChannelMessageFilter::InsertSyncPointOnMainThread, gpu_channel_, sync_point_manager_, message.routing_id(), - get<0>(retire), sync_point)); + base::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 33a73e05a1f54d..bdc4ffbe77d6a7 100644 --- a/content/common/gpu/media/android_video_encode_accelerator.cc +++ b/content/common/gpu/media/android_video_encode_accelerator.cc @@ -253,7 +253,8 @@ void AndroidVideoEncodeAccelerator::Encode( "Non-packed frame, or visible_rect != coded_size", kInvalidArgumentError); - pending_frames_.push(MakeTuple(frame, force_keyframe, base::Time::Now())); + pending_frames_.push( + base::MakeTuple(frame, force_keyframe, base::Time::Now())); DoIOTask(); } @@ -320,7 +321,7 @@ void AndroidVideoEncodeAccelerator::QueueInput() { } const PendingFrames::value_type& input = pending_frames_.front(); - bool is_key_frame = get<1>(input); + bool is_key_frame = base::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 +329,7 @@ void AndroidVideoEncodeAccelerator::QueueInput() { // Instead, we request a key frame "soon". media_codec_->RequestKeyFrameSoon(); } - scoped_refptr frame = get<0>(input); + scoped_refptr frame = base::get<0>(input); uint8* buffer = NULL; size_t capacity = 0; @@ -365,7 +366,7 @@ void AndroidVideoEncodeAccelerator::QueueInput() { status = media_codec_->QueueInputBuffer( input_buf_index, NULL, queued_size, fake_input_timestamp_); UMA_HISTOGRAM_TIMES("Media.AVEA.InputQueueTime", - base::Time::Now() - get<2>(input)); + base::Time::Now() - base::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 c828de8493f8b4..e0ae0eb1b04461 100644 --- a/content/common/gpu/media/android_video_encode_accelerator.h +++ b/content/common/gpu/media/android_video_encode_accelerator.h @@ -85,7 +85,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 . typedef std::queue< - Tuple, bool, base::Time>> + base::Tuple, 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 fb0a2173e9bfbd..04978bc61837ff 100644 --- a/content/common/gpu/media/video_decode_accelerator_unittest.cc +++ b/content/common/gpu/media/video_decode_accelerator_unittest.cc @@ -82,6 +82,8 @@ using media::VideoDecodeAccelerator; namespace content { namespace { +using base::MakeTuple; + // Values optionally filled in from flags; see main() below. // The syntax of multiple test videos is: // test-video1;test-video2;test-video3 @@ -1177,17 +1179,18 @@ void VideoDecodeAcceleratorTest::OutputLogFile( class VideoDecodeAcceleratorParamTest : public VideoDecodeAcceleratorTest, public ::testing::WithParamInterface< - Tuple > { + base::Tuple > { }; // Helper so that gtest failures emit a more readable version of the tuple than // its byte representation. ::std::ostream& operator<<( ::std::ostream& os, - const Tuple& t) { - return os << get<0>(t) << ", " << get<1>(t) << ", " << get<2>(t) << ", " - << get<3>(t) << ", " << get<4>(t) << ", " << get<5>(t) << ", " - << get<6>(t); + const base::Tuple& t) { + return os << base::get<0>(t) << ", " << base::get<1>(t) << ", " + << base::get<2>(t) << ", " << base::get<3>(t) << ", " + << base::get<4>(t) << ", " << base::get<5>(t) << ", " + << base::get<6>(t); } // Wait for |note| to report a state and if it's not |expected_state| then @@ -1211,13 +1214,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 = 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()); + size_t num_concurrent_decoders = base::get<0>(GetParam()); + const size_t num_in_flight_decodes = base::get<1>(GetParam()); + int num_play_throughs = base::get<2>(GetParam()); + const int reset_point = base::get<3>(GetParam()); + const int delete_decoder_state = base::get<4>(GetParam()); + bool test_reuse_delay = base::get<5>(GetParam()); + const bool render_as_thumbnails = base::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 f676372ec7b577..c9e60556c9a05c 100644 --- a/content/common/gpu/media/video_encode_accelerator_unittest.cc +++ b/content/common/gpu/media/video_encode_accelerator_unittest.cc @@ -1326,16 +1326,16 @@ void VEAClient::WriteIvfFrameHeader(int frame_index, size_t frame_size) { // - If true, switch framerate mid-stream. class VideoEncodeAcceleratorTest : public ::testing::TestWithParam< - Tuple> {}; + base::Tuple> {}; TEST_P(VideoEncodeAcceleratorTest, TestSimpleEncode) { - 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()); + size_t num_concurrent_encoders = base::get<0>(GetParam()); + const bool save_to_file = base::get<1>(GetParam()); + const unsigned int keyframe_period = base::get<2>(GetParam()); + const bool force_bitrate = base::get<3>(GetParam()); + const bool test_perf = base::get<4>(GetParam()); + const bool mid_stream_bitrate_switch = base::get<5>(GetParam()); + const bool mid_stream_framerate_switch = base::get<6>(GetParam()); ScopedVector > notes; ScopedVector clients; @@ -1393,39 +1393,40 @@ TEST_P(VideoEncodeAcceleratorTest, TestSimpleEncode) { INSTANTIATE_TEST_CASE_P( SimpleEncode, VideoEncodeAcceleratorTest, - ::testing::Values(MakeTuple(1, true, 0, false, false, false, false))); + ::testing::Values(base::MakeTuple(1, true, 0, false, false, false, false))); INSTANTIATE_TEST_CASE_P( EncoderPerf, VideoEncodeAcceleratorTest, - ::testing::Values(MakeTuple(1, false, 0, false, true, false, false))); + ::testing::Values(base::MakeTuple(1, false, 0, false, true, false, false))); INSTANTIATE_TEST_CASE_P( ForceKeyframes, VideoEncodeAcceleratorTest, - ::testing::Values(MakeTuple(1, false, 10, false, false, false, false))); + ::testing::Values(base::MakeTuple(1, false, 10, false, false, false, + false))); INSTANTIATE_TEST_CASE_P( ForceBitrate, VideoEncodeAcceleratorTest, - ::testing::Values(MakeTuple(1, false, 0, true, false, false, false))); + ::testing::Values(base::MakeTuple(1, false, 0, true, false, false, false))); INSTANTIATE_TEST_CASE_P( MidStreamParamSwitchBitrate, VideoEncodeAcceleratorTest, - ::testing::Values(MakeTuple(1, false, 0, true, false, true, false))); + ::testing::Values(base::MakeTuple(1, false, 0, true, false, true, false))); INSTANTIATE_TEST_CASE_P( MidStreamParamSwitchFPS, VideoEncodeAcceleratorTest, - ::testing::Values(MakeTuple(1, false, 0, true, false, false, true))); + ::testing::Values(base::MakeTuple(1, false, 0, true, false, false, true))); INSTANTIATE_TEST_CASE_P( MultipleEncoders, VideoEncodeAcceleratorTest, - ::testing::Values(MakeTuple(3, false, 0, false, false, false, false), - MakeTuple(3, false, 0, true, false, false, true), - MakeTuple(3, false, 0, true, false, true, false))); + ::testing::Values(base::MakeTuple(3, false, 0, false, false, false, false), + base::MakeTuple(3, false, 0, true, false, false, true), + base::MakeTuple(3, false, 0, true, false, true, false))); // TODO(posciak): more tests: // - async FeedEncoderWithOutput diff --git a/content/renderer/accessibility/renderer_accessibility_browsertest.cc b/content/renderer/accessibility/renderer_accessibility_browsertest.cc index 667294305a52c3..b237d238f03693 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); - Tuple, int> param; + base::Tuple, int> param; AccessibilityHostMsg_Events::Read(message, ¶m); - ASSERT_GE(get<0>(param).size(), 1U); - *params = get<0>(param)[0]; + ASSERT_GE(base::get<0>(param).size(), 1U); + *params = base::get<0>(param)[0]; } int CountAccessibilityNodesSentToBrowser() { @@ -404,9 +404,9 @@ TEST_F(RendererAccessibilityTest, EventOnObjectNotInTree) { const IPC::Message* message = sink_->GetUniqueMessageMatching(AccessibilityHostMsg_Events::ID); ASSERT_TRUE(message); - Tuple, int> param; + base::Tuple, int> param; AccessibilityHostMsg_Events::Read(message, ¶m); - ASSERT_EQ(0U, get<0>(param).size()); + ASSERT_EQ(0U, base::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 bdab282eb472d0..c25823ca5697fc 100644 --- a/content/renderer/browser_plugin/browser_plugin.cc +++ b/content/renderer/browser_plugin/browser_plugin.cc @@ -182,15 +182,15 @@ void BrowserPlugin::OnCompositorFrameSwapped(const IPC::Message& message) { guest_crashed_ = false; scoped_ptr frame(new cc::CompositorFrame); - get<1>(param).frame.AssignTo(frame.get()); + base::get<1>(param).frame.AssignTo(frame.get()); EnableCompositing(true); 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); + base::get<1>(param).producing_route_id, + base::get<1>(param).output_surface_id, + base::get<1>(param).producing_host_id, + base::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 a4861864f7c5f0..2a305dddf698d6 100644 --- a/content/renderer/browser_plugin/browser_plugin_manager.cc +++ b/content/renderer/browser_plugin/browser_plugin_manager.cc @@ -124,11 +124,11 @@ void BrowserPluginManager::OnCompositorFrameSwappedPluginUnavailable( return; FrameHostMsg_CompositorFrameSwappedACK_Params params; - 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; + params.producing_host_id = base::get<1>(param).producing_host_id; + params.producing_route_id = base::get<1>(param).producing_route_id; + params.output_surface_id = base::get<1>(param).output_surface_id; Send(new BrowserPluginHostMsg_CompositorFrameSwappedACK( - get<0>(param), params)); + base::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 0cd2ddb7b2e3e4..885070e3793a5c 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); - Tuple param; + base::Tuple param; FrameHostMsg_ShowPopup::Read(message, ¶m); - ASSERT_EQ(3U, get<0>(param).popup_items.size()); - EXPECT_EQ(1, get<0>(param).selected_item); + ASSERT_EQ(3U, base::get<0>(param).popup_items.size()); + EXPECT_EQ(1, base::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, ¶m); - ASSERT_EQ(3U, get<0>(param).popup_items.size()); - EXPECT_EQ(0, get<0>(param).selected_item); + ASSERT_EQ(3U, base::get<0>(param).popup_items.size()); + EXPECT_EQ(0, base::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); - Tuple param; + base::Tuple param; FrameHostMsg_ShowPopup::Read(message, ¶m); // Number of items should match item count minus the number // of "display: none" items. - ASSERT_EQ(5U, get<0>(param).popup_items.size()); + ASSERT_EQ(5U, base::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 62d7c45b49ddc3..4d487bd6bf9a52 100644 --- a/content/renderer/input/input_event_filter.cc +++ b/content/renderer/input/input_event_filter.cc @@ -145,9 +145,9 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) { InputMsg_HandleInputEvent::Param params; if (!InputMsg_HandleInputEvent::Read(&message, ¶ms)) return; - const WebInputEvent* event = get<0>(params); - ui::LatencyInfo latency_info = get<1>(params); - bool is_keyboard_shortcut = get<2>(params); + const WebInputEvent* event = base::get<0>(params); + ui::LatencyInfo latency_info = base::get<1>(params); + bool is_keyboard_shortcut = base::get<2>(params); DCHECK(event); const bool send_ack = WebInputEventTraits::WillReceiveAckFromRenderer(*event); diff --git a/content/renderer/input/input_event_filter_unittest.cc b/content/renderer/input/input_event_filter_unittest.cc index 6795504fb8e490..d9a3505808ed4e 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, ¶ms)); - WebInputEvent::Type event_type = get<0>(params).type; - InputEventAckState ack_result = get<0>(params).state; + WebInputEvent::Type event_type = base::get<0>(params).type; + InputEventAckState ack_result = base::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, ¶ms)); - const WebInputEvent* event = get<0>(params); + const WebInputEvent* event = base::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, ¶ms)); - WebInputEvent::Type event_type = get<0>(params).type; - InputEventAckState ack_result = get<0>(params).state; + WebInputEvent::Type event_type = base::get<0>(params).type; + InputEventAckState ack_result = base::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 0f036507ca6b19..d182034187784e 100644 --- a/content/renderer/media/render_media_log_unittest.cc +++ b/content/renderer/media/render_media_log_unittest.cc @@ -44,9 +44,9 @@ class RenderMediaLogTest : public testing::Test { return std::vector(); } - Tuple> events; + base::Tuple> events; ViewHostMsg_MediaLogEvents::Read(msg, &events); - return get<0>(events); + return base::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 0585b04416b236..6d4a4d24e65b7c 100644 --- a/content/renderer/pepper/pepper_file_chooser_host_unittest.cc +++ b/content/renderer/pepper/pepper_file_chooser_host_unittest.cc @@ -92,7 +92,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 = get<0>(call_msg_param); + const FileChooserParams& chooser_params = base::get<0>(call_msg_param); // Basic validation of request. EXPECT_EQ(FileChooserParams::Open, chooser_params.mode); @@ -124,7 +124,7 @@ TEST_F(PepperFileChooserHostTest, Show) { ASSERT_TRUE( PpapiPluginMsg_FileChooser_ShowReply::Read(&reply_msg, &reply_msg_param)); const std::vector& chooser_results = - get<0>(reply_msg_param); + base::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 7444d1cc45c7c1..cb74cd1590e328 100644 --- a/content/renderer/pepper/plugin_power_saver_helper_browsertest.cc +++ b/content/renderer/pepper/plugin_power_saver_helper_browsertest.cc @@ -129,7 +129,7 @@ TEST_F(PluginPowerSaverHelperTest, TemporaryOriginWhitelist) { EXPECT_EQ(FrameHostMsg_PluginContentOriginAllowed::ID, msg->type()); FrameHostMsg_PluginContentOriginAllowed::Param params; FrameHostMsg_PluginContentOriginAllowed::Read(msg, ¶ms); - EXPECT_EQ(GURL("http://b.com"), get<0>(params)); + EXPECT_EQ(GURL("http://b.com"), base::get<0>(params)); } TEST_F(PluginPowerSaverHelperTest, UnthrottleOnExPostFactoWhitelist) { diff --git a/content/renderer/render_frame_proxy.cc b/content/renderer/render_frame_proxy.cc index 54d8085ac5b3d4..68c405bf759ade 100644 --- a/content/renderer/render_frame_proxy.cc +++ b/content/renderer/render_frame_proxy.cc @@ -246,7 +246,7 @@ void RenderFrameProxy::OnCompositorFrameSwapped(const IPC::Message& message) { return; scoped_ptr frame(new cc::CompositorFrame); - get<0>(param).frame.AssignTo(frame.get()); + base::get<0>(param).frame.AssignTo(frame.get()); if (!compositing_helper_.get()) { compositing_helper_ = @@ -255,10 +255,10 @@ void RenderFrameProxy::OnCompositorFrameSwapped(const IPC::Message& message) { } 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); + base::get<0>(param).producing_route_id, + base::get<0>(param).output_surface_id, + base::get<0>(param).producing_host_id, + base::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 8cb8e2ab7690d6..b7898f597251f8 100644 --- a/content/renderer/render_view_browsertest.cc +++ b/content/renderer/render_view_browsertest.cc @@ -406,8 +406,8 @@ TEST_F(RenderViewImplTest, SaveImageFromDataURL) { ViewHostMsg_SaveImageFromDataURL::Param param1; ViewHostMsg_SaveImageFromDataURL::Read(msg2, ¶m1); - EXPECT_EQ(get<1>(param1).length(), image_data_url.length()); - EXPECT_EQ(get<1>(param1), image_data_url); + EXPECT_EQ(base::get<1>(param1).length(), image_data_url.length()); + EXPECT_EQ(base::get<1>(param1), image_data_url); ProcessPendingMessages(); render_thread_->sink().ClearMessages(); @@ -422,8 +422,8 @@ TEST_F(RenderViewImplTest, SaveImageFromDataURL) { ViewHostMsg_SaveImageFromDataURL::Param param2; ViewHostMsg_SaveImageFromDataURL::Read(msg3, ¶m2); - EXPECT_EQ(get<1>(param2).length(), large_data_url.length()); - EXPECT_EQ(get<1>(param2), large_data_url); + EXPECT_EQ(base::get<1>(param2).length(), large_data_url.length()); + EXPECT_EQ(base::get<1>(param2), large_data_url); ProcessPendingMessages(); render_thread_->sink().ClearMessages(); @@ -488,12 +488,12 @@ TEST_F(RenderViewImplTest, OnNavigationHttpPost) { FrameHostMsg_DidCommitProvisionalLoad::Param host_nav_params; FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg, &host_nav_params); - EXPECT_TRUE(get<0>(host_nav_params).is_post); + EXPECT_TRUE(base::get<0>(host_nav_params).is_post); // Check post data sent to browser matches - EXPECT_TRUE(get<0>(host_nav_params).page_state.IsValid()); + EXPECT_TRUE(base::get<0>(host_nav_params).page_state.IsValid()); scoped_ptr entry = - PageStateToHistoryEntry(get<0>(host_nav_params).page_state); + PageStateToHistoryEntry(base::get<0>(host_nav_params).page_state); blink::WebHTTPBody body = entry->root().httpBody(); blink::WebHTTPBody::Element element; bool successful = body.elementAt(0, element); @@ -699,8 +699,8 @@ TEST_F(RenderViewImplTest, ReloadWhileSwappedOut) { ASSERT_TRUE(msg_A); ViewHostMsg_UpdateState::Param params; ViewHostMsg_UpdateState::Read(msg_A, ¶ms); - int page_id_A = get<0>(params); - PageState state_A = get<1>(params); + int page_id_A = base::get<0>(params); + PageState state_A = base::get<1>(params); EXPECT_EQ(1, page_id_A); render_thread_->sink().ClearMessages(); @@ -758,7 +758,7 @@ TEST_F(RenderViewImplTest, ReloadWhileSwappedOut) { FrameHostMsg_DidCommitProvisionalLoad::Param commit_load_params; FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg, &commit_load_params); - EXPECT_NE(GURL("swappedout://"), get<0>(commit_load_params).url); + EXPECT_NE(GURL("swappedout://"), base::get<0>(commit_load_params).url); } // Verify that security origins are replicated properly to RenderFrameProxies @@ -818,8 +818,8 @@ TEST_F(RenderViewImplTest, DISABLED_LastCommittedUpdateState) { ASSERT_TRUE(msg_A); ViewHostMsg_UpdateState::Param param; ViewHostMsg_UpdateState::Read(msg_A, ¶m); - int page_id_A = get<0>(param); - PageState state_A = get<1>(param); + int page_id_A = base::get<0>(param); + PageState state_A = base::get<1>(param); EXPECT_EQ(1, page_id_A); render_thread_->sink().ClearMessages(); @@ -832,8 +832,8 @@ TEST_F(RenderViewImplTest, DISABLED_LastCommittedUpdateState) { ViewHostMsg_UpdateState::ID); ASSERT_TRUE(msg_B); ViewHostMsg_UpdateState::Read(msg_B, ¶m); - int page_id_B = get<0>(param); - PageState state_B = get<1>(param); + int page_id_B = base::get<0>(param); + PageState state_B = base::get<1>(param); EXPECT_EQ(2, page_id_B); EXPECT_NE(state_A, state_B); render_thread_->sink().ClearMessages(); @@ -847,8 +847,8 @@ TEST_F(RenderViewImplTest, DISABLED_LastCommittedUpdateState) { ViewHostMsg_UpdateState::ID); ASSERT_TRUE(msg_C); ViewHostMsg_UpdateState::Read(msg_C, ¶m); - int page_id_C = get<0>(param); - PageState state_C = get<1>(param); + int page_id_C = base::get<0>(param); + PageState state_C = base::get<1>(param); EXPECT_EQ(3, page_id_C); EXPECT_NE(state_B, state_C); render_thread_->sink().ClearMessages(); @@ -902,8 +902,8 @@ TEST_F(RenderViewImplTest, DISABLED_LastCommittedUpdateState) { ViewHostMsg_UpdateState::ID); ASSERT_TRUE(msg); ViewHostMsg_UpdateState::Read(msg, ¶m); - int page_id = get<0>(param); - PageState state = get<1>(param); + int page_id = base::get<0>(param); + PageState state = base::get<1>(param); EXPECT_EQ(page_id_C, page_id); EXPECT_NE(state_A, state); EXPECT_NE(state_B, state); @@ -930,8 +930,8 @@ TEST_F(RenderViewImplTest, StaleNavigationsIgnored) { ASSERT_TRUE(msg_A); ViewHostMsg_UpdateState::Param param; ViewHostMsg_UpdateState::Read(msg_A, ¶m); - int page_id_A = get<0>(param); - PageState state_A = get<1>(param); + int page_id_A = base::get<0>(param); + PageState state_A = base::get<1>(param); EXPECT_EQ(1, page_id_A); render_thread_->sink().ClearMessages(); @@ -1060,9 +1060,9 @@ TEST_F(RenderViewImplTest, OnImeTypeChanged) { EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type()); ViewHostMsg_TextInputTypeChanged::Param params; ViewHostMsg_TextInputTypeChanged::Read(msg, ¶ms); - ui::TextInputType type = get<0>(params); - ui::TextInputMode input_mode = get<1>(params); - bool can_compose_inline = get<2>(params); + ui::TextInputType type = base::get<0>(params); + ui::TextInputMode input_mode = base::get<1>(params); + bool can_compose_inline = base::get<2>(params); EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT, type); EXPECT_EQ(true, can_compose_inline); @@ -1079,8 +1079,8 @@ TEST_F(RenderViewImplTest, OnImeTypeChanged) { EXPECT_TRUE(msg != NULL); EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type()); ViewHostMsg_TextInputTypeChanged::Read(msg, & params); - type = get<0>(params); - input_mode = get<1>(params); + type = base::get<0>(params); + input_mode = base::get<1>(params); EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD, type); for (size_t i = 0; i < arraysize(kInputModeTestCases); i++) { @@ -1101,8 +1101,8 @@ TEST_F(RenderViewImplTest, OnImeTypeChanged) { EXPECT_TRUE(msg != NULL); EXPECT_EQ(ViewHostMsg_TextInputTypeChanged::ID, msg->type()); ViewHostMsg_TextInputTypeChanged::Read(msg, & params); - type = get<0>(params); - input_mode = get<1>(params); + type = base::get<0>(params); + input_mode = base::get<1>(params); EXPECT_EQ(test_case->expected_mode, input_mode); } } @@ -2227,7 +2227,7 @@ TEST_F(RenderViewImplTest, FocusElementCallsFocusedNodeChanged) { ViewHostMsg_FocusedNodeChanged::Param params; ViewHostMsg_FocusedNodeChanged::Read(msg1, ¶ms); - EXPECT_TRUE(get<0>(params)); + EXPECT_TRUE(base::get<0>(params)); render_thread_->sink().ClearMessages(); ExecuteJavaScript("document.getElementById('test2').focus();"); @@ -2235,7 +2235,7 @@ TEST_F(RenderViewImplTest, FocusElementCallsFocusedNodeChanged) { ViewHostMsg_FocusedNodeChanged::ID); EXPECT_TRUE(msg2); ViewHostMsg_FocusedNodeChanged::Read(msg2, ¶ms); - EXPECT_TRUE(get<0>(params)); + EXPECT_TRUE(base::get<0>(params)); render_thread_->sink().ClearMessages(); view()->webview()->clearFocusedElement(); @@ -2243,7 +2243,7 @@ TEST_F(RenderViewImplTest, FocusElementCallsFocusedNodeChanged) { ViewHostMsg_FocusedNodeChanged::ID); EXPECT_TRUE(msg3); ViewHostMsg_FocusedNodeChanged::Read(msg3, ¶ms); - EXPECT_FALSE(get<0>(params)); + EXPECT_FALSE(base::get<0>(params)); render_thread_->sink().ClearMessages(); } diff --git a/content/renderer/render_widget_unittest.cc b/content/renderer/render_widget_unittest.cc index 431b2fa5fd59cf..d9b919aef2fa55 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, ¶ms); - InputEventAckState ack_state = get<0>(params).state; + InputEventAckState ack_state = base::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, ¶ms); - ack_state = get<0>(params).state; + ack_state = base::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, ¶ms); - InputEventAckState ack_state = get<0>(params).state; + InputEventAckState ack_state = base::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, ¶ms); - ack_state = get<0>(params).state; + ack_state = base::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 afaef3a73de328..f6086a4f951a01 100644 --- a/content/renderer/screen_orientation/screen_orientation_dispatcher_unittest.cc +++ b/content/renderer/screen_orientation/screen_orientation_dispatcher_unittest.cc @@ -74,9 +74,9 @@ class ScreenOrientationDispatcherTest : public testing::Test { ScreenOrientationHostMsg_LockRequest::ID); EXPECT_TRUE(msg != NULL); - Tuple params; + base::Tuple params; ScreenOrientationHostMsg_LockRequest::Read(msg, ¶ms); - return get<1>(params); + return base::get<1>(params); } IPC::TestSink& sink() { diff --git a/extensions/browser/api/alarms/alarms_api_unittest.cc b/extensions/browser/api/alarms/alarms_api_unittest.cc index 541b8ff5976fd5..6f9b2644171ffd 100644 --- a/extensions/browser/api/alarms/alarms_api_unittest.cc +++ b/extensions/browser/api/alarms/alarms_api_unittest.cc @@ -297,8 +297,8 @@ TEST_F(ExtensionAlarmsTest, CreateDelayBelowMinimum) { ASSERT_TRUE(warning); ExtensionMsg_AddMessageToConsole::Param params; ExtensionMsg_AddMessageToConsole::Read(warning, ¶ms); - content::ConsoleMessageLevel level = get<0>(params); - std::string message = get<1>(params); + content::ConsoleMessageLevel level = base::get<0>(params); + std::string message = base::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/extensions/browser/sandboxed_unpacker.cc b/extensions/browser/sandboxed_unpacker.cc index de7267fab14558..38a7cd9afec01a 100644 --- a/extensions/browser/sandboxed_unpacker.cc +++ b/extensions/browser/sandboxed_unpacker.cc @@ -742,8 +742,8 @@ bool SandboxedUnpacker::RewriteImageFiles(SkBitmap* install_icon) { return false; } - const SkBitmap& image = get<0>(images[i]); - base::FilePath path_suffix = get<1>(images[i]); + const SkBitmap& image = base::get<0>(images[i]); + base::FilePath path_suffix = base::get<1>(images[i]); if (path_suffix.MaybeAsASCII() == install_icon_path) *install_icon = image; diff --git a/extensions/common/extension_utility_messages.h b/extensions/common/extension_utility_messages.h index 8c0fd30bb32b31..1d140472d5d44c 100644 --- a/extensions/common/extension_utility_messages.h +++ b/extensions/common/extension_utility_messages.h @@ -16,7 +16,7 @@ #ifndef EXTENSIONS_COMMON_EXTENSION_UTILITY_MESSAGES_H_ #define EXTENSIONS_COMMON_EXTENSION_UTILITY_MESSAGES_H_ -typedef std::vector> DecodedImages; +typedef std::vector> DecodedImages; #endif // EXTENSIONS_COMMON_EXTENSION_UTILITY_MESSAGES_H_ diff --git a/extensions/utility/unpacker.cc b/extensions/utility/unpacker.cc index c61faa24f53e74..a65aabb30e455f 100644 --- a/extensions/utility/unpacker.cc +++ b/extensions/utility/unpacker.cc @@ -264,7 +264,7 @@ bool Unpacker::AddDecodedImage(const base::FilePath& path) { return false; } - internal_data_->decoded_images.push_back(MakeTuple(image_bitmap, path)); + internal_data_->decoded_images.push_back(base::MakeTuple(image_bitmap, path)); return true; } diff --git a/ipc/ipc_message_macros.h b/ipc/ipc_message_macros.h index e0e16d55925c94..3f7574fd31ae00 100644 --- a/ipc/ipc_message_macros.h +++ b/ipc/ipc_message_macros.h @@ -457,7 +457,7 @@ void (T::*func)(P*, TA)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, get<0>(p)); \ + (obj->*func)(parameter, base::get<0>(p)); \ return true; \ } \ return false; \ @@ -469,7 +469,7 @@ void (T::*func)(P*, TA, TB)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, get<0>(p), get<1>(p)); \ + (obj->*func)(parameter, base::get<0>(p), base::get<1>(p)); \ return true; \ } \ return false; \ @@ -481,7 +481,8 @@ void (T::*func)(P*, TA, TB, TC)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p)); \ + (obj->*func)(parameter, base::get<0>(p), base::get<1>(p), \ + base::get<2>(p)); \ return true; \ } \ return false; \ @@ -494,7 +495,8 @@ void (T::*func)(P*, TA, TB, TC, TD)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p)); \ + (obj->*func)(parameter, base::get<0>(p), base::get<1>(p), \ + base::get<2>(p), base::get<3>(p)); \ return true; \ } \ return false; \ @@ -507,8 +509,8 @@ void (T::*func)(P*, TA, TB, TC, TD, TE)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p), \ - get<4>(p)); \ + (obj->*func)(parameter, base::get<0>(p), base::get<1>(p), \ + base::get<2>(p), base::get<3>(p), base::get<4>(p)); \ return true; \ } \ return false; \ @@ -636,7 +638,7 @@ static bool ReadSendParam(const Message* msg, Schema::SendParam* p); \ static bool ReadReplyParam( \ const Message* msg, \ - TupleTypes::ValueTuple* p); \ + base::TupleTypes::ValueTuple* p); \ static void Log(std::string* name, const Message* msg, std::string* l); \ IPC_SYNC_MESSAGE_METHODS_##out_cnt \ }; @@ -658,7 +660,7 @@ static bool ReadSendParam(const Message* msg, Schema::SendParam* p); \ static bool ReadReplyParam( \ const Message* msg, \ - TupleTypes::ValueTuple* p); \ + base::TupleTypes::ValueTuple* p); \ static void Log(std::string* name, const Message* msg, std::string* l); \ IPC_SYNC_MESSAGE_METHODS_##out_cnt \ }; @@ -711,8 +713,9 @@ bool msg_class::ReadSendParam(const Message* msg, Schema::SendParam* p) { \ return Schema::ReadSendParam(msg, p); \ } \ - bool msg_class::ReadReplyParam(const Message* msg, \ - TupleTypes::ValueTuple* p) { \ + bool msg_class::ReadReplyParam( \ + const Message* msg, \ + base::TupleTypes::ValueTuple* p) { \ return Schema::ReadReplyParam(msg, p); \ } @@ -731,8 +734,9 @@ bool msg_class::ReadSendParam(const Message* msg, Schema::SendParam* p) { \ return Schema::ReadSendParam(msg, p); \ } \ - bool msg_class::ReadReplyParam(const Message* msg, \ - TupleTypes::ValueTuple* p) { \ + bool msg_class::ReadReplyParam( \ + const Message* msg, \ + base::TupleTypes::ValueTuple* p) { \ return Schema::ReadReplyParam(msg, p); \ } @@ -766,12 +770,12 @@ if (!msg || !l) \ return; \ if (msg->is_sync()) { \ - TupleTypes::ValueTuple p; \ + base::TupleTypes::ValueTuple p; \ if (Schema::ReadSendParam(msg, &p)) \ IPC::LogParam(p, l); \ AddOutputParamsToLog(msg, l); \ } else { \ - TupleTypes::ValueTuple p; \ + base::TupleTypes::ValueTuple p; \ if (Schema::ReadReplyParam(msg, &p)) \ IPC::LogParam(p, l); \ } \ @@ -816,33 +820,38 @@ #define IPC_TYPE_OUT_1(t1) t1* arg6 #define IPC_TYPE_OUT_2(t1, t2) t1* arg6, t2* arg7 #define IPC_TYPE_OUT_3(t1, t2, t3) t1* arg6, t2* arg7, t3* arg8 -#define IPC_TYPE_OUT_4(t1, t2, t3, t4) t1* arg6, t2* arg7, t3* arg8, t4* arg9 - -#define IPC_TUPLE_IN_0() Tuple<> -#define IPC_TUPLE_IN_1(t1) Tuple -#define IPC_TUPLE_IN_2(t1, t2) Tuple -#define IPC_TUPLE_IN_3(t1, t2, t3) Tuple -#define IPC_TUPLE_IN_4(t1, t2, t3, t4) Tuple -#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5) Tuple - -#define IPC_TUPLE_OUT_0() Tuple<> -#define IPC_TUPLE_OUT_1(t1) Tuple -#define IPC_TUPLE_OUT_2(t1, t2) Tuple -#define IPC_TUPLE_OUT_3(t1, t2, t3) Tuple -#define IPC_TUPLE_OUT_4(t1, t2, t3, t4) Tuple - -#define IPC_NAME_IN_0() MakeTuple() -#define IPC_NAME_IN_1(t1) MakeRefTuple(arg1) -#define IPC_NAME_IN_2(t1, t2) MakeRefTuple(arg1, arg2) -#define IPC_NAME_IN_3(t1, t2, t3) MakeRefTuple(arg1, arg2, arg3) -#define IPC_NAME_IN_4(t1, t2, t3, t4) MakeRefTuple(arg1, arg2, arg3, arg4) -#define IPC_NAME_IN_5(t1, t2, t3, t4, t5) MakeRefTuple(arg1, arg2, arg3, arg4, arg5) - -#define IPC_NAME_OUT_0() MakeTuple() -#define IPC_NAME_OUT_1(t1) MakeRefTuple(*arg6) -#define IPC_NAME_OUT_2(t1, t2) MakeRefTuple(*arg6, *arg7) -#define IPC_NAME_OUT_3(t1, t2, t3) MakeRefTuple(*arg6, *arg7, *arg8) -#define IPC_NAME_OUT_4(t1, t2, t3, t4) MakeRefTuple(*arg6, *arg7, *arg8, *arg9) +#define IPC_TYPE_OUT_4(t1, t2, t3, t4) t1* arg6, t2* arg7, t3* arg8, \ + t4* arg9 + +#define IPC_TUPLE_IN_0() base::Tuple<> +#define IPC_TUPLE_IN_1(t1) base::Tuple +#define IPC_TUPLE_IN_2(t1, t2) base::Tuple +#define IPC_TUPLE_IN_3(t1, t2, t3) base::Tuple +#define IPC_TUPLE_IN_4(t1, t2, t3, t4) base::Tuple +#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5) base::Tuple + +#define IPC_TUPLE_OUT_0() base::Tuple<> +#define IPC_TUPLE_OUT_1(t1) base::Tuple +#define IPC_TUPLE_OUT_2(t1, t2) base::Tuple +#define IPC_TUPLE_OUT_3(t1, t2, t3) base::Tuple +#define IPC_TUPLE_OUT_4(t1, t2, t3, t4) base::Tuple + +#define IPC_NAME_IN_0() base::MakeTuple() +#define IPC_NAME_IN_1(t1) base::MakeRefTuple(arg1) +#define IPC_NAME_IN_2(t1, t2) base::MakeRefTuple(arg1, arg2) +#define IPC_NAME_IN_3(t1, t2, t3) base::MakeRefTuple(arg1, arg2, arg3) +#define IPC_NAME_IN_4(t1, t2, t3, t4) base::MakeRefTuple(arg1, arg2, \ + arg3, arg4) +#define IPC_NAME_IN_5(t1, t2, t3, t4, t5) base::MakeRefTuple(arg1, arg2, \ + arg3, arg4, arg5) + +#define IPC_NAME_OUT_0() base::MakeTuple() +#define IPC_NAME_OUT_1(t1) base::MakeRefTuple(*arg6) +#define IPC_NAME_OUT_2(t1, t2) base::MakeRefTuple(*arg6, *arg7) +#define IPC_NAME_OUT_3(t1, t2, t3) base::MakeRefTuple(*arg6, *arg7, \ + *arg8) +#define IPC_NAME_OUT_4(t1, t2, t3, t4) base::MakeRefTuple(*arg6, *arg7, \ + *arg8, *arg9) // There are places where the syntax requires a comma if there are input args, // if there are input args and output args, or if there are input args or diff --git a/ipc/ipc_message_utils.h b/ipc/ipc_message_utils.h index 6787c8e2eb80dd..71bfbdf538001a 100644 --- a/ipc/ipc_message_utils.h +++ b/ipc/ipc_message_utils.h @@ -503,8 +503,8 @@ struct IPC_EXPORT ParamTraits { }; template <> -struct ParamTraits> { - typedef Tuple<> param_type; +struct ParamTraits> { + typedef base::Tuple<> param_type; static void Write(Message* m, const param_type& p) { } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { @@ -515,112 +515,112 @@ struct ParamTraits> { }; template -struct ParamTraits> { - typedef Tuple param_type; +struct ParamTraits> { + typedef base::Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, get<0>(p)); + WriteParam(m, base::get<0>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return ReadParam(m, iter, &get<0>(*r)); + return ReadParam(m, iter, &base::get<0>(*r)); } static void Log(const param_type& p, std::string* l) { - LogParam(get<0>(p), l); + LogParam(base::get<0>(p), l); } }; template -struct ParamTraits< Tuple > { - typedef Tuple param_type; +struct ParamTraits> { + typedef base::Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, get<0>(p)); - WriteParam(m, get<1>(p)); + WriteParam(m, base::get<0>(p)); + WriteParam(m, base::get<1>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return (ReadParam(m, iter, &get<0>(*r)) && - ReadParam(m, iter, &get<1>(*r))); + return (ReadParam(m, iter, &base::get<0>(*r)) && + ReadParam(m, iter, &base::get<1>(*r))); } static void Log(const param_type& p, std::string* l) { - LogParam(get<0>(p), l); + LogParam(base::get<0>(p), l); l->append(", "); - LogParam(get<1>(p), l); + LogParam(base::get<1>(p), l); } }; template -struct ParamTraits< Tuple > { - typedef Tuple param_type; +struct ParamTraits> { + typedef base::Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, get<0>(p)); - WriteParam(m, get<1>(p)); - WriteParam(m, get<2>(p)); + WriteParam(m, base::get<0>(p)); + WriteParam(m, base::get<1>(p)); + WriteParam(m, base::get<2>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return (ReadParam(m, iter, &get<0>(*r)) && - ReadParam(m, iter, &get<1>(*r)) && - ReadParam(m, iter, &get<2>(*r))); + return (ReadParam(m, iter, &base::get<0>(*r)) && + ReadParam(m, iter, &base::get<1>(*r)) && + ReadParam(m, iter, &base::get<2>(*r))); } static void Log(const param_type& p, std::string* l) { - LogParam(get<0>(p), l); + LogParam(base::get<0>(p), l); l->append(", "); - LogParam(get<1>(p), l); + LogParam(base::get<1>(p), l); l->append(", "); - LogParam(get<2>(p), l); + LogParam(base::get<2>(p), l); } }; template -struct ParamTraits< Tuple > { - typedef Tuple param_type; +struct ParamTraits> { + typedef base::Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, get<0>(p)); - WriteParam(m, get<1>(p)); - WriteParam(m, get<2>(p)); - WriteParam(m, get<3>(p)); + WriteParam(m, base::get<0>(p)); + WriteParam(m, base::get<1>(p)); + WriteParam(m, base::get<2>(p)); + WriteParam(m, base::get<3>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return (ReadParam(m, iter, &get<0>(*r)) && - ReadParam(m, iter, &get<1>(*r)) && - ReadParam(m, iter, &get<2>(*r)) && - ReadParam(m, iter, &get<3>(*r))); + return (ReadParam(m, iter, &base::get<0>(*r)) && + ReadParam(m, iter, &base::get<1>(*r)) && + ReadParam(m, iter, &base::get<2>(*r)) && + ReadParam(m, iter, &base::get<3>(*r))); } static void Log(const param_type& p, std::string* l) { - LogParam(get<0>(p), l); + LogParam(base::get<0>(p), l); l->append(", "); - LogParam(get<1>(p), l); + LogParam(base::get<1>(p), l); l->append(", "); - LogParam(get<2>(p), l); + LogParam(base::get<2>(p), l); l->append(", "); - LogParam(get<3>(p), l); + LogParam(base::get<3>(p), l); } }; template -struct ParamTraits< Tuple > { - typedef Tuple param_type; +struct ParamTraits> { + typedef base::Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, get<0>(p)); - WriteParam(m, get<1>(p)); - WriteParam(m, get<2>(p)); - WriteParam(m, get<3>(p)); - WriteParam(m, get<4>(p)); + WriteParam(m, base::get<0>(p)); + WriteParam(m, base::get<1>(p)); + WriteParam(m, base::get<2>(p)); + WriteParam(m, base::get<3>(p)); + WriteParam(m, base::get<4>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return (ReadParam(m, iter, &get<0>(*r)) && - ReadParam(m, iter, &get<1>(*r)) && - ReadParam(m, iter, &get<2>(*r)) && - ReadParam(m, iter, &get<3>(*r)) && - ReadParam(m, iter, &get<4>(*r))); + return (ReadParam(m, iter, &base::get<0>(*r)) && + ReadParam(m, iter, &base::get<1>(*r)) && + ReadParam(m, iter, &base::get<2>(*r)) && + ReadParam(m, iter, &base::get<3>(*r)) && + ReadParam(m, iter, &base::get<4>(*r))); } static void Log(const param_type& p, std::string* l) { - LogParam(get<0>(p), l); + LogParam(base::get<0>(p), l); l->append(", "); - LogParam(get<1>(p), l); + LogParam(base::get<1>(p), l); l->append(", "); - LogParam(get<2>(p), l); + LogParam(base::get<2>(p), l); l->append(", "); - LogParam(get<3>(p), l); + LogParam(base::get<3>(p), l); l->append(", "); - LogParam(get<4>(p), l); + LogParam(base::get<4>(p), l); } }; @@ -788,7 +788,7 @@ template class MessageSchema { public: typedef ParamType Param; - typedef typename TupleTypes::ParamTuple RefParam; + typedef typename base::TupleTypes::ParamTuple RefParam; static void Write(Message* msg, const RefParam& p) IPC_MSG_NOINLINE; static bool Read(const Message* msg, Param* p) IPC_MSG_NOINLINE; @@ -861,14 +861,14 @@ template class SyncMessageSchema { public: typedef SendParamType SendParam; - typedef typename TupleTypes::ParamTuple RefSendParam; + typedef typename base::TupleTypes::ParamTuple RefSendParam; typedef ReplyParamType ReplyParam; static void Write(Message* msg, const RefSendParam& send) IPC_MSG_NOINLINE; static bool ReadSendParam(const Message* msg, SendParam* p) IPC_MSG_NOINLINE; static bool ReadReplyParam( const Message* msg, - typename TupleTypes::ValueTuple* p) IPC_MSG_NOINLINE; + typename base::TupleTypes::ValueTuple* p) IPC_MSG_NOINLINE; template static bool DispatchWithSendParams(bool ok, const SendParam& send_params, @@ -876,7 +876,7 @@ class SyncMessageSchema { Method func) { Message* reply = SyncMessage::GenerateReply(msg); if (ok) { - typename TupleTypes::ValueTuple reply_params; + typename base::TupleTypes::ValueTuple reply_params; DispatchToMethod(obj, func, send_params, &reply_params); WriteParam(reply, reply_params); LogReplyParamsToMessage(reply_params, msg); @@ -895,7 +895,7 @@ class SyncMessageSchema { Method func) { Message* reply = SyncMessage::GenerateReply(msg); if (ok) { - Tuple t = MakeRefTuple(*reply); + base::Tuple t = base::MakeRefTuple(*reply); ConnectMessageAndReply(msg, reply); DispatchToMethod(obj, func, send_params, &t); } else { diff --git a/ipc/ipc_message_utils_impl.h b/ipc/ipc_message_utils_impl.h index 0931e30216b969..f441be3fe457f7 100644 --- a/ipc/ipc_message_utils_impl.h +++ b/ipc/ipc_message_utils_impl.h @@ -41,7 +41,7 @@ bool SyncMessageSchema::ReadSendParam( template bool SyncMessageSchema::ReadReplyParam( - const Message* msg, typename TupleTypes::ValueTuple* p) { + const Message* msg, typename base::TupleTypes::ValueTuple* p) { PickleIterator iter = SyncMessage::GetDataIterator(msg); return ReadParam(msg, &iter, p); } diff --git a/ipc/ipc_test_sink.h b/ipc/ipc_test_sink.h index 75e582db682829..0781db0700b872 100644 --- a/ipc/ipc_test_sink.h +++ b/ipc/ipc_test_sink.h @@ -45,7 +45,7 @@ class Message; // // IPC::Message* msg = test_sink.GetUniqueMessageMatching(IPC_REPLY_ID); // ASSERT_TRUE(msg); -// TupleTypes::ValueTuple reply_data; +// base::TupleTypes::ValueTuple reply_data; // EXPECT_TRUE(ViewHostMsg_Foo::ReadReplyParam(msg, &reply_data)); // // You can also register to be notified when messages are posted to the sink. diff --git a/net/quic/quic_session_test.cc b/net/quic/quic_session_test.cc index 4e79df15a336bb..206c93c1f9620f 100644 --- a/net/quic/quic_session_test.cc +++ b/net/quic/quic_session_test.cc @@ -383,13 +383,13 @@ TEST_P(QuicSessionTestServer, OnCanWriteBundlesStreams) { EXPECT_CALL(*send_algorithm, GetCongestionWindow()) .WillRepeatedly(Return(kMaxPacketSize * 10)); EXPECT_CALL(*stream2, OnCanWrite()) - .WillOnce(IgnoreResult(Invoke(CreateFunctor( + .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor( &session_, &TestSession::SendStreamData, stream2->id())))); EXPECT_CALL(*stream4, OnCanWrite()) - .WillOnce(IgnoreResult(Invoke(CreateFunctor( + .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor( &session_, &TestSession::SendStreamData, stream4->id())))); EXPECT_CALL(*stream6, OnCanWrite()) - .WillOnce(IgnoreResult(Invoke(CreateFunctor( + .WillOnce(testing::IgnoreResult(Invoke(CreateFunctor( &session_, &TestSession::SendStreamData, stream6->id())))); // Expect that we only send one packet, the writes from different streams diff --git a/ppapi/host/dispatch_host_message.h b/ppapi/host/dispatch_host_message.h index 80b8a343a7f3e1..5d05019cd0e3e2 100644 --- a/ppapi/host/dispatch_host_message.h +++ b/ppapi/host/dispatch_host_message.h @@ -22,45 +22,47 @@ struct HostMessageContext; template inline int32_t DispatchResourceCall(ObjT* obj, Method method, HostMessageContext* context, - Tuple<>& arg) { + base::Tuple<>& arg) { return (obj->*method)(context); } template inline int32_t DispatchResourceCall(ObjT* obj, Method method, HostMessageContext* context, - Tuple& arg) { - return (obj->*method)(context, get<0>(arg)); + base::Tuple& arg) { + return (obj->*method)(context, base::get<0>(arg)); } template inline int32_t DispatchResourceCall(ObjT* obj, Method method, HostMessageContext* context, - Tuple& arg) { - return (obj->*method)(context, get<0>(arg), get<1>(arg)); + base::Tuple& arg) { + return (obj->*method)(context, base::get<0>(arg), base::get<1>(arg)); } template inline int32_t DispatchResourceCall(ObjT* obj, Method method, HostMessageContext* context, - Tuple& arg) { - return (obj->*method)(context, get<0>(arg), get<1>(arg), get<2>(arg)); + base::Tuple& arg) { + return (obj->*method)(context, base::get<0>(arg), base::get<1>(arg), + base::get<2>(arg)); } template inline int32_t DispatchResourceCall(ObjT* obj, Method method, HostMessageContext* context, - Tuple& arg) { - return (obj->*method)(context, get<0>(arg), get<1>(arg), get<2>(arg), - get<3>(arg)); + base::Tuple& arg) { + return (obj->*method)(context, base::get<0>(arg), base::get<1>(arg), + base::get<2>(arg), base::get<3>(arg)); } template inline int32_t DispatchResourceCall(ObjT* obj, Method method, HostMessageContext* context, - Tuple& arg) { - return (obj->*method)(context, get<0>(arg), get<1>(arg), get<2>(arg), - get<3>(arg), get<4>(arg)); + base::Tuple& arg) { + return (obj->*method)(context, base::get<0>(arg), base::get<1>(arg), + base::get<2>(arg), base::get<3>(arg), + base::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 3e8b74f4db89c6..2d664174341c7e 100644 --- a/ppapi/proxy/dispatch_reply_message.h +++ b/ppapi/proxy/dispatch_reply_message.h @@ -22,44 +22,46 @@ class ResourceMessageReplyParams; template inline void DispatchResourceReply(ObjT* obj, Method method, const ResourceMessageReplyParams& params, - const Tuple<>& arg) { + const base::Tuple<>& arg) { (obj->*method)(params); } template inline void DispatchResourceReply(ObjT* obj, Method method, const ResourceMessageReplyParams& params, - const Tuple& arg) { - (obj->*method)(params, get<0>(arg)); + const base::Tuple& arg) { + (obj->*method)(params, base::get<0>(arg)); } template inline void DispatchResourceReply(ObjT* obj, Method method, const ResourceMessageReplyParams& params, - const Tuple& arg) { - (obj->*method)(params, get<0>(arg), get<1>(arg)); + const base::Tuple& arg) { + (obj->*method)(params, base::get<0>(arg), base::get<1>(arg)); } template inline void DispatchResourceReply(ObjT* obj, Method method, const ResourceMessageReplyParams& params, - const Tuple& arg) { - (obj->*method)(params, get<0>(arg), get<1>(arg), get<2>(arg)); + const base::Tuple& arg) { + (obj->*method)(params, base::get<0>(arg), base::get<1>(arg), + base::get<2>(arg)); } template inline void DispatchResourceReply(ObjT* obj, Method method, const ResourceMessageReplyParams& params, - const Tuple& arg) { - (obj->*method)(params, get<0>(arg), get<1>(arg), get<2>(arg), get<3>(arg)); + const base::Tuple& arg) { + (obj->*method)(params, base::get<0>(arg), base::get<1>(arg), + base::get<2>(arg), base::get<3>(arg)); } template inline void DispatchResourceReply(ObjT* obj, Method method, const ResourceMessageReplyParams& params, - const Tuple& arg) { - (obj->*method)(params, get<0>(arg), get<1>(arg), get<2>(arg), get<3>(arg), - get<4>(arg)); + const base::Tuple& arg) { + (obj->*method)(params, base::get<0>(arg), base::get<1>(arg), + base::get<2>(arg), base::get<3>(arg), base::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 a31ba624872b8b..a48ae8ea769271 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 -void ScanTuple(const Tuple& t1, ScanningResults* results) { - ScanParam(get<0>(t1), results); +void ScanTuple(const base::Tuple& t1, ScanningResults* results) { + ScanParam(base::get<0>(t1), results); } template -void ScanTuple(const Tuple& t1, ScanningResults* results) { - ScanParam(get<0>(t1), results); - ScanParam(get<1>(t1), results); +void ScanTuple(const base::Tuple& t1, ScanningResults* results) { + ScanParam(base::get<0>(t1), results); + ScanParam(base::get<1>(t1), results); } template -void ScanTuple(const Tuple& t1, ScanningResults* results) { - ScanParam(get<0>(t1), results); - ScanParam(get<1>(t1), results); - ScanParam(get<2>(t1), results); +void ScanTuple(const base::Tuple& t1, ScanningResults* results) { + ScanParam(base::get<0>(t1), results); + ScanParam(base::get<1>(t1), results); + ScanParam(base::get<2>(t1), results); } template -void ScanTuple(const Tuple& t1, ScanningResults* results) { - ScanParam(get<0>(t1), results); - ScanParam(get<1>(t1), results); - ScanParam(get<2>(t1), results); - ScanParam(get<3>(t1), results); +void ScanTuple(const base::Tuple& t1, ScanningResults* results) { + ScanParam(base::get<0>(t1), results); + ScanParam(base::get<1>(t1), results); + ScanParam(base::get<2>(t1), results); + ScanParam(base::get<3>(t1), results); } template @@ -178,7 +178,8 @@ class MessageScannerImpl { : msg_(static_cast(msg)) { } bool ScanMessage(ScanningResults* results) { - typename TupleTypes::ValueTuple params; + typename base::TupleTypes::ValueTuple + params; if (!MessageType::Read(msg_, ¶ms)) return false; ScanTuple(params, results); @@ -186,8 +187,8 @@ class MessageScannerImpl { } bool ScanReply(ScanningResults* results) { - typename TupleTypes::ValueTuple - params; + typename base::TupleTypes + ::ValueTuple params; if (!MessageType::ReadReplyParam(msg_, ¶ms)) return false; // If we need to rewrite the message, write the message id first. diff --git a/ppapi/proxy/plugin_var_tracker_unittest.cc b/ppapi/proxy/plugin_var_tracker_unittest.cc index fe0a82dd9b6ae9..51d50365cd3d01 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; - Tuple id; + base::Tuple id; PpapiHostMsg_PPBVar_ReleaseObject::Read(release_msg, &id); - return get<0>(id); + return base::get<0>(id); } }; diff --git a/ppapi/proxy/ppapi_message_utils.h b/ppapi/proxy/ppapi_message_utils.h index 7c4fc0ce7d1b63..e4757e5d07fbfc 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 -struct TupleTypeMatch1, A> { +struct TupleTypeMatch1, A> { static const bool kValue = true; }; @@ -32,7 +32,7 @@ struct TupleTypeMatch2 { static const bool kValue = false; }; template -struct TupleTypeMatch2, A, B> { +struct TupleTypeMatch2, A, B> { static const bool kValue = true; }; @@ -41,7 +41,7 @@ struct TupleTypeMatch3 { static const bool kValue = false; }; template -struct TupleTypeMatch3, A, B, C> { +struct TupleTypeMatch3, A, B, C> { static const bool kValue = true; }; @@ -50,7 +50,7 @@ struct TupleTypeMatch4 { static const bool kValue = false; }; template -struct TupleTypeMatch4, A, B, C, D> { +struct TupleTypeMatch4, A, B, C, D> { static const bool kValue = true; }; @@ -59,7 +59,7 @@ struct TupleTypeMatch5 { static const bool kValue = false; }; template -struct TupleTypeMatch5, A, B, C, D, E> { +struct TupleTypeMatch5, A, B, C, D, E> { static const bool kValue = true; }; diff --git a/ppapi/proxy/ppapi_proxy_test.cc b/ppapi/proxy/ppapi_proxy_test.cc index 949dac39d2eee7..64b00e26c6947b 100644 --- a/ppapi/proxy/ppapi_proxy_test.cc +++ b/ppapi/proxy/ppapi_proxy_test.cc @@ -135,12 +135,13 @@ bool ProxyTestHarnessBase::SupportsInterface(const char* name) { if (!reply_msg) return false; - TupleTypes::ValueTuple reply_data; + base::TupleTypes::ValueTuple + reply_data; EXPECT_TRUE(PpapiMsg_SupportsInterface::ReadReplyParam( reply_msg, &reply_data)); sink().ClearMessages(); - return get<0>(reply_data); + return base::get<0>(reply_data); } // PluginProxyTestHarness ------------------------------------------------------ diff --git a/ppapi/proxy/resource_message_test_sink.cc b/ppapi/proxy/resource_message_test_sink.cc index 2ce9f41a2d8436..b3f3724e9eb1db 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, ¶ms); - Params cur_params = get<0>(params); - IPC::Message cur_msg = get<1>(params); + Params cur_params = base::get<0>(params); + IPC::Message cur_msg = base::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 = get<0>(send_params); - IPC::Message call_msg = get<1>(send_params); + ResourceMessageCallParams call_params = base::get<0>(send_params); + IPC::Message call_msg = base::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 f65c2a59223d4c..bdc0b885494889 100644 --- a/ppapi/proxy/websocket_resource_unittest.cc +++ b/ppapi/proxy/websocket_resource_unittest.cc @@ -78,9 +78,9 @@ TEST_F(WebSocketResourceTest, Connect) { PpapiHostMsg_WebSocket_Connect::ID, ¶ms, &msg)); PpapiHostMsg_WebSocket_Connect::Schema::Param p; PpapiHostMsg_WebSocket_Connect::Read(&msg, &p); - EXPECT_EQ(url, get<0>(p)); - EXPECT_EQ(protocol0, get<1>(p)[0]); - EXPECT_EQ(protocol1, get<1>(p)[1]); + EXPECT_EQ(url, base::get<0>(p)); + EXPECT_EQ(protocol0, base::get<1>(p)[0]); + EXPECT_EQ(protocol1, base::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 85bf00e5705e45..3f8f38bab3b0b8 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 Tuple PdfRenderSettingsBase; +typedef base::Tuple 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 ::get<0>(*this); } - int dpi() const { return ::get<1>(*this); } - bool autorotate() const { return ::get<2>(*this); } + const gfx::Rect& area() const { return base::get<0>(*this); } + int dpi() const { return base::get<1>(*this); } + bool autorotate() const { return base::get<2>(*this); } }; } // namespace printing diff --git a/sandbox/linux/bpf_dsl/codegen.cc b/sandbox/linux/bpf_dsl/codegen.cc index bc2c7a29464233..2d5c8e406e9ee2 100644 --- a/sandbox/linux/bpf_dsl/codegen.cc +++ b/sandbox/linux/bpf_dsl/codegen.cc @@ -145,14 +145,14 @@ size_t CodeGen::Offset(Node target) const { // TODO(mdempsky): Move into a general base::Tuple helper library. bool CodeGen::MemoKeyLess::operator()(const MemoKey& lhs, const MemoKey& rhs) const { - if (get<0>(lhs) != get<0>(rhs)) - return get<0>(lhs) < get<0>(rhs); - if (get<1>(lhs) != get<1>(rhs)) - return get<1>(lhs) < get<1>(rhs); - if (get<2>(lhs) != get<2>(rhs)) - return get<2>(lhs) < get<2>(rhs); - if (get<3>(lhs) != get<3>(rhs)) - return get<3>(lhs) < get<3>(rhs); + if (base::get<0>(lhs) != base::get<0>(rhs)) + return base::get<0>(lhs) < base::get<0>(rhs); + if (base::get<1>(lhs) != base::get<1>(rhs)) + return base::get<1>(lhs) < base::get<1>(rhs); + if (base::get<2>(lhs) != base::get<2>(rhs)) + return base::get<2>(lhs) < base::get<2>(rhs); + if (base::get<3>(lhs) != base::get<3>(rhs)) + return base::get<3>(lhs) < base::get<3>(rhs); return false; } diff --git a/sandbox/linux/bpf_dsl/codegen.h b/sandbox/linux/bpf_dsl/codegen.h index c2e1f937a65fd5..9d898030b9d399 100644 --- a/sandbox/linux/bpf_dsl/codegen.h +++ b/sandbox/linux/bpf_dsl/codegen.h @@ -81,7 +81,7 @@ class SANDBOX_EXPORT CodeGen { void Compile(Node head, Program* program); private: - using MemoKey = Tuple; + using MemoKey = base::Tuple; struct MemoKeyLess { bool operator()(const MemoKey& lhs, const MemoKey& rhs) const; }; diff --git a/storage/browser/fileapi/copy_or_move_operation_delegate.cc b/storage/browser/fileapi/copy_or_move_operation_delegate.cc index ee6248707a3d86..1cb92f5a838d37 100644 --- a/storage/browser/fileapi/copy_or_move_operation_delegate.cc +++ b/storage/browser/fileapi/copy_or_move_operation_delegate.cc @@ -406,21 +406,21 @@ class StreamCopyOrMoveImpl void NotifyOnStartUpdate(const FileSystemURL& url) { if (file_system_context_->GetUpdateObservers(url.type())) { file_system_context_->GetUpdateObservers(url.type()) - ->Notify(&FileUpdateObserver::OnStartUpdate, MakeTuple(url)); + ->Notify(&FileUpdateObserver::OnStartUpdate, base::MakeTuple(url)); } } void NotifyOnModifyFile(const FileSystemURL& url) { if (file_system_context_->GetChangeObservers(url.type())) { file_system_context_->GetChangeObservers(url.type()) - ->Notify(&FileChangeObserver::OnModifyFile, MakeTuple(url)); + ->Notify(&FileChangeObserver::OnModifyFile, base::MakeTuple(url)); } } void NotifyOnEndUpdate(const FileSystemURL& url) { if (file_system_context_->GetUpdateObservers(url.type())) { file_system_context_->GetUpdateObservers(url.type()) - ->Notify(&FileUpdateObserver::OnEndUpdate, MakeTuple(url)); + ->Notify(&FileUpdateObserver::OnEndUpdate, base::MakeTuple(url)); } } diff --git a/storage/browser/fileapi/file_system_operation_impl.cc b/storage/browser/fileapi/file_system_operation_impl.cc index c48d26a07dbe35..bf259672068ccf 100644 --- a/storage/browser/fileapi/file_system_operation_impl.cc +++ b/storage/browser/fileapi/file_system_operation_impl.cc @@ -551,7 +551,7 @@ void FileSystemOperationImpl::DidWrite( if (complete && write_status != FileWriterDelegate::ERROR_WRITE_NOT_STARTED) { DCHECK(operation_context_); operation_context_->change_observers()->Notify( - &FileChangeObserver::OnModifyFile, MakeTuple(url)); + &FileChangeObserver::OnModifyFile, base::MakeTuple(url)); } StatusCallback cancel_callback = cancel_callback_; diff --git a/storage/browser/fileapi/file_system_operation_runner.cc b/storage/browser/fileapi/file_system_operation_runner.cc index 62b8f2fc7df681..8dc39e6c747c33 100644 --- a/storage/browser/fileapi/file_system_operation_runner.cc +++ b/storage/browser/fileapi/file_system_operation_runner.cc @@ -632,7 +632,7 @@ void FileSystemOperationRunner::PrepareForWrite(OperationID id, const FileSystemURL& url) { if (file_system_context_->GetUpdateObservers(url.type())) { file_system_context_->GetUpdateObservers(url.type())->Notify( - &FileUpdateObserver::OnStartUpdate, MakeTuple(url)); + &FileUpdateObserver::OnStartUpdate, base::MakeTuple(url)); } write_target_urls_[id].insert(url); } @@ -641,7 +641,7 @@ void FileSystemOperationRunner::PrepareForRead(OperationID id, const FileSystemURL& url) { if (file_system_context_->GetAccessObservers(url.type())) { file_system_context_->GetAccessObservers(url.type())->Notify( - &FileAccessObserver::OnAccess, MakeTuple(url)); + &FileAccessObserver::OnAccess, base::MakeTuple(url)); } } @@ -663,7 +663,7 @@ void FileSystemOperationRunner::FinishOperation(OperationID id) { iter != urls.end(); ++iter) { if (file_system_context_->GetUpdateObservers(iter->type())) { file_system_context_->GetUpdateObservers(iter->type())->Notify( - &FileUpdateObserver::OnEndUpdate, MakeTuple(*iter)); + &FileUpdateObserver::OnEndUpdate, base::MakeTuple(*iter)); } } write_target_urls_.erase(found); diff --git a/storage/browser/fileapi/obfuscated_file_util.cc b/storage/browser/fileapi/obfuscated_file_util.cc index 2bff7057d9f839..67421c130249f3 100644 --- a/storage/browser/fileapi/obfuscated_file_util.cc +++ b/storage/browser/fileapi/obfuscated_file_util.cc @@ -88,7 +88,7 @@ void UpdateUsage( const FileSystemURL& url, int64 growth) { context->update_observers()->Notify( - &FileUpdateObserver::OnUpdate, MakeTuple(url, growth)); + &FileUpdateObserver::OnUpdate, base::MakeTuple(url, growth)); } void TouchDirectory(SandboxDirectoryDatabase* db, FileId dir_id) { @@ -319,7 +319,7 @@ base::File::Error ObfuscatedFileUtil::EnsureFileExists( *created = true; UpdateUsage(context, url, growth); context->change_observers()->Notify( - &FileChangeObserver::OnCreateFile, MakeTuple(url)); + &FileChangeObserver::OnCreateFile, base::MakeTuple(url)); } return error; } @@ -378,7 +378,7 @@ base::File::Error ObfuscatedFileUtil::CreateDirectory( return error; UpdateUsage(context, url, growth); context->change_observers()->Notify( - &FileChangeObserver::OnCreateDirectory, MakeTuple(url)); + &FileChangeObserver::OnCreateDirectory, base::MakeTuple(url)); if (first) { first = false; TouchDirectory(db, file_info.parent_id); @@ -479,7 +479,7 @@ base::File::Error ObfuscatedFileUtil::Truncate( if (error == base::File::FILE_OK) { UpdateUsage(context, url, growth); context->change_observers()->Notify( - &FileChangeObserver::OnModifyFile, MakeTuple(url)); + &FileChangeObserver::OnModifyFile, base::MakeTuple(url)); } return error; } @@ -606,16 +606,16 @@ base::File::Error ObfuscatedFileUtil::CopyOrMoveFile( if (overwrite) { context->change_observers()->Notify( &FileChangeObserver::OnModifyFile, - MakeTuple(dest_url)); + base::MakeTuple(dest_url)); } else { context->change_observers()->Notify( &FileChangeObserver::OnCreateFileFrom, - MakeTuple(dest_url, src_url)); + base::MakeTuple(dest_url, src_url)); } if (!copy) { context->change_observers()->Notify( - &FileChangeObserver::OnRemoveFile, MakeTuple(src_url)); + &FileChangeObserver::OnRemoveFile, base::MakeTuple(src_url)); TouchDirectory(db, src_file_info.parent_id); } @@ -694,10 +694,10 @@ base::File::Error ObfuscatedFileUtil::CopyInForeignFile( if (overwrite) { context->change_observers()->Notify( - &FileChangeObserver::OnModifyFile, MakeTuple(dest_url)); + &FileChangeObserver::OnModifyFile, base::MakeTuple(dest_url)); } else { context->change_observers()->Notify( - &FileChangeObserver::OnCreateFile, MakeTuple(dest_url)); + &FileChangeObserver::OnCreateFile, base::MakeTuple(dest_url)); } UpdateUsage(context, dest_url, growth); @@ -737,7 +737,7 @@ base::File::Error ObfuscatedFileUtil::DeleteFile( TouchDirectory(db, file_info.parent_id); context->change_observers()->Notify( - &FileChangeObserver::OnRemoveFile, MakeTuple(url)); + &FileChangeObserver::OnRemoveFile, base::MakeTuple(url)); if (error == base::File::FILE_ERROR_NOT_FOUND) return base::File::FILE_OK; @@ -772,7 +772,7 @@ base::File::Error ObfuscatedFileUtil::DeleteDirectory( UpdateUsage(context, url, growth); TouchDirectory(db, file_info.parent_id); context->change_observers()->Notify( - &FileChangeObserver::OnRemoveDirectory, MakeTuple(url)); + &FileChangeObserver::OnRemoveDirectory, base::MakeTuple(url)); return base::File::FILE_OK; } @@ -1366,7 +1366,7 @@ base::File ObfuscatedFileUtil::CreateOrOpenInternal( if (file.IsValid()) { UpdateUsage(context, url, growth); context->change_observers()->Notify( - &FileChangeObserver::OnCreateFile, MakeTuple(url)); + &FileChangeObserver::OnCreateFile, base::MakeTuple(url)); } return file.Pass(); } @@ -1409,7 +1409,7 @@ base::File ObfuscatedFileUtil::CreateOrOpenInternal( if (delta) { UpdateUsage(context, url, delta); context->change_observers()->Notify( - &FileChangeObserver::OnModifyFile, MakeTuple(url)); + &FileChangeObserver::OnModifyFile, base::MakeTuple(url)); } return file.Pass(); } diff --git a/storage/browser/fileapi/sandbox_file_stream_writer.cc b/storage/browser/fileapi/sandbox_file_stream_writer.cc index 4655e75c90b27f..74748949ad2e53 100644 --- a/storage/browser/fileapi/sandbox_file_stream_writer.cc +++ b/storage/browser/fileapi/sandbox_file_stream_writer.cc @@ -212,7 +212,7 @@ void SandboxFileStreamWriter::DidWrite( if (overlapped < 0) overlapped = 0; observers_.Notify(&FileUpdateObserver::OnUpdate, - MakeTuple(url_, write_response - overlapped)); + base::MakeTuple(url_, write_response - overlapped)); } total_bytes_written_ += write_response; diff --git a/testing/generate_gmock_mutant.py b/testing/generate_gmock_mutant.py index a6ee4c3cd3a967..9c5678c2f296df 100755 --- a/testing/generate_gmock_mutant.py +++ b/testing/generate_gmock_mutant.py @@ -113,7 +113,7 @@ // #include "base/memory/linked_ptr.h" -#include "base/tuple.h" // for Tuple +#include "base/tuple.h" namespace testing {""" @@ -202,7 +202,7 @@ class MutantLateObjectBind : public MutantRunner { } inline R operator()() { - return impl_->RunWithParams(Tuple<>()); + return impl_->RunWithParams(base::Tuple<>()); } template @@ -276,7 +276,7 @@ class MutantLateObjectBind : public MutantRunner { MutantRunner* t = new Mutant - (obj, method, MakeTuple(%(call_args)s)); + (obj, method, base::MakeTuple(%(call_args)s)); return MutantFunctor(t); } """ @@ -288,14 +288,14 @@ class MutantLateObjectBind : public MutantRunner { MutantRunner* t = new MutantFunction - (function, MakeTuple(%(call_args)s)); + (function, base::MakeTuple(%(call_args)s)); return MutantFunctor(t); } """ def SplitLine(line, width): """Splits a single line at comma, at most |width| characters long.""" - if len(line) < width: + if len(line) <= width: return (line, None) n = 1 + line[:width].rfind(",") if n == 0: # If comma cannot be found give up and return the entire line. @@ -352,14 +352,18 @@ def Merge(a): def GenTuple(pattern, n): - return Clean("Tuple<%s>" % (Gen(pattern, n, 1))) + return Clean("base::Tuple<%s>" % (Gen(pattern, n, 1))) def FixCode(s): lines = Clean(s).splitlines() - # Wrap sometimes very long 1st and 3rd line at 80th column. + # Wrap sometimes very long 1st line to be inside the "template <" lines[0] = Wrap(lines[0], 80, 10) - lines[2] = Wrap(lines[2], 80, 4) + + # Wrap all subsequent lines to 6 spaces arbitrarily. This is a 2-space line + # indent, plus a 4 space continuation indent. + for line in xrange(1, len(lines)): + lines[line] = Wrap(lines[line], 80, 6) return "\n".join(lines) @@ -370,8 +374,8 @@ def GenerateDispatch(prebound, calltime): Gen("typename C%", calltime, 1)]), "prebound": GenTuple("P%", prebound), "calltime": GenTuple("C%", calltime), - "args": Merge([Gen("get<%>(p)", prebound, 0), - Gen("get<%>(c)", calltime, 0)]), + "args": Merge([Gen("base::get<%>(p)", prebound, 0), + Gen("base::get<%>(c)", calltime, 0)]), } print FixCode(DISPATCH_TO_METHOD_TEMPLATE % args) diff --git a/testing/gmock_mutant.h b/testing/gmock_mutant.h index 964d56b3388ac8..acc1ae92496294 100644 --- a/testing/gmock_mutant.h +++ b/testing/gmock_mutant.h @@ -104,313 +104,335 @@ // #include "base/memory/linked_ptr.h" -#include "base/tuple.h" // for Tuple +#include "base/tuple.h" namespace testing { // 0 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple<>& p, - const Tuple<>& c) { + const base::Tuple<>& p, + const base::Tuple<>& c) { return (obj->*method)(); } template inline R DispatchToFunction(Function function, - const Tuple<>& p, - const Tuple<>& c) { + const base::Tuple<>& p, + const base::Tuple<>& c) { return (*function)(); } // 0 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple<>& p, - const Tuple& c) { - return (obj->*method)(get<0>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple<>& p, - const Tuple& c) { - return (*function)(get<0>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (*function)(base::get<0>(c)); } // 0 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple<>& p, - const Tuple& c) { - return (obj->*method)(get<0>(c), get<1>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(c), base::get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple<>& p, - const Tuple& c) { - return (*function)(get<0>(c), get<1>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (*function)(base::get<0>(c), base::get<1>(c)); } // 0 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple<>& p, - const Tuple& c) { - return (obj->*method)(get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(c), base::get<1>(c), base::get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple<>& p, - const Tuple& c) { - return (*function)(get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (*function)(base::get<0>(c), base::get<1>(c), base::get<2>(c)); } // 0 - 4 template inline R DispatchToMethod(T* obj, Method method, - const Tuple<>& p, - const Tuple& c) { - return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple<>& p, - const Tuple& c) { - return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (*function)(base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c)); } // 0 - 5 template inline R DispatchToMethod(T* obj, Method method, - const Tuple<>& p, - const Tuple& c) { - return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c), base::get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple<>& p, - const Tuple& c) { - return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (*function)(base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c), base::get<4>(c)); } // 0 - 6 template inline R DispatchToMethod(T* obj, Method method, - const Tuple<>& p, - const Tuple& c) { - return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c), base::get<4>(c), base::get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple<>& p, - const Tuple& c) { - return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple<>& p, + const base::Tuple& c) { + return (*function)(base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c), base::get<4>(c), base::get<5>(c)); } // 1 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple<>& c) { - return (obj->*method)(get<0>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (obj->*method)(base::get<0>(p)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple<>& c) { - return (*function)(get<0>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (*function)(base::get<0>(p)); } // 1 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<0>(c)); } // 1 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c)); } // 1 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c)); } // 1 - 4 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c)); } // 1 - 5 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c), base::get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c), base::get<4>(c)); } // 1 - 6 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c), base::get<4>(c), base::get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c), base::get<4>(c), base::get<5>(c)); } // 2 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple<>& c) { - return (obj->*method)(get<0>(p), get<1>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple<>& c) { - return (*function)(get<0>(p), get<1>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (*function)(base::get<0>(p), base::get<1>(p)); } // 2 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c)); } // 2 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c)); } // 2 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c)); } // 2 - 4 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c)); } // 2 - 5 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c)); } // 2 - 6 @@ -418,95 +440,107 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c), + base::get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c), + base::get<5>(c)); } // 3 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple<>& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple<>& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p)); } // 3 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c)); } // 3 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c)); } // 3 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c), base::get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c), base::get<2>(c)); } // 3 - 4 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c)); } // 3 - 5 @@ -514,16 +548,20 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c), + base::get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c), + base::get<4>(c)); } // 3 - 6 @@ -531,81 +569,93 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c), + base::get<4>(c), base::get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<0>(c), base::get<1>(c), base::get<2>(c), base::get<3>(c), + base::get<4>(c), base::get<5>(c)); } // 4 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple<>& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple<>& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p)); } // 4 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c)); } // 4 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c)); } // 4 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c)); } // 4 - 4 @@ -613,16 +663,20 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c)); } // 4 - 5 @@ -630,17 +684,21 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c), base::get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c), base::get<4>(c)); } // 4 - 6 @@ -648,65 +706,75 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c), base::get<4>(c), base::get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<0>(c), base::get<1>(c), base::get<2>(c), + base::get<3>(c), base::get<4>(c), base::get<5>(c)); } // 5 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple<>& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple<>& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p)); } // 5 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c)); } // 5 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c)); } // 5 - 3 @@ -714,16 +782,20 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c)); } // 5 - 4 @@ -731,17 +803,21 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c)); } // 5 - 5 @@ -749,17 +825,21 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c), base::get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c), base::get<4>(c)); } // 5 - 6 @@ -767,49 +847,57 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c), base::get<4>(c), base::get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<0>(c), base::get<1>(c), + base::get<2>(c), base::get<3>(c), base::get<4>(c), base::get<5>(c)); } // 6 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple<>& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple<>& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p)); + const base::Tuple& p, + const base::Tuple<>& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p)); } // 6 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c)); } // 6 - 2 @@ -817,16 +905,20 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c)); } // 6 - 3 @@ -834,17 +926,21 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c)); } // 6 - 4 @@ -852,17 +948,21 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c)); } // 6 - 5 @@ -870,17 +970,21 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c)); } // 6 - 6 @@ -888,17 +992,23 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple& p, - const Tuple& c) { - return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (obj->*method)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c), + base::get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple& p, - const Tuple& c) { - return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); + const base::Tuple& p, + const base::Tuple& c) { + return (*function)(base::get<0>(p), base::get<1>(p), base::get<2>(p), + base::get<3>(p), base::get<4>(p), base::get<5>(p), base::get<0>(c), + base::get<1>(c), base::get<2>(c), base::get<3>(c), base::get<4>(c), + base::get<5>(c)); } // Interface that is exposed to the consumer, that does the actual calling @@ -984,7 +1094,7 @@ struct MutantFunctor { } inline R operator()() { - return impl_->RunWithParams(Tuple<>()); + return impl_->RunWithParams(base::Tuple<>()); } template @@ -1017,198 +1127,198 @@ struct MutantFunctor { // 0 - 0 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)()) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple<>> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)()) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple<>> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)()) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple<>> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)()) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple<>> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)()) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple<>> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)()) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple<>> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) // 0 - 1 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(A1)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) // 0 - 2 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1216,69 +1326,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) { // 0 - 3 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2, A3)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2, A3)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2, A3)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2, A3)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1286,69 +1396,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) { // 0 - 4 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2, A3, A4)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1356,71 +1466,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) { // 0 - 5 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2, A3, A4, A5)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1428,137 +1538,137 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) { // 0 - 6 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2, A3, A4, A5, A6)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5, A6)) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (function, base::MakeTuple()); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple()); - return MutantFunctor>(t); + base::Tuple<>, base::Tuple> + (obj, method, base::MakeTuple()); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) // 1 - 0 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1566,69 +1676,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) { // 1 - 1 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1636,69 +1746,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) { // 1 - 2 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1706,71 +1816,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) { // 1 - 3 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2, A3), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1778,73 +1888,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) { // 1 - 4 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1852,73 +1962,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4), // 1 - 5 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1927,39 +2037,39 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -1967,39 +2077,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5, A6), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6), - const P1& p1) { - MutantRunner>* t = + const P1& p1) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2007,71 +2117,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6), // 2 - 0 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2079,74 +2189,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1, // 2 - 1 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> -CreateFunctor(R (__stdcall *function)(X1, X2, A1), const P1& p1, - const P2& p2) { - MutantRunner>* t = +inline MutantFunctor> +CreateFunctor(R (__stdcall *function)(X1, X2, A1), const P1& p1, const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2154,76 +2263,76 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1, // 2 - 2 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2231,76 +2340,76 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1, // 2 - 3 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) { - MutantRunner>* t = + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2309,40 +2418,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2350,39 +2459,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2391,40 +2500,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2432,39 +2541,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2473,41 +2582,42 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1, - const P2& p2) { - MutantRunner>* t = + const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2515,40 +2625,41 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2) { - MutantRunner>* t = + const P1& p1, const P2& p2) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2556,77 +2667,77 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), // 3 - 0 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2, - const P3& p3) { - MutantRunner>* t = + const P3& p3) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3), const P1& p1, const P2& p2, - const P3& p3) { - MutantRunner>* t = + const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2, - const P3& p3) { - MutantRunner>* t = + const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3), const P1& p1, const P2& p2, - const P3& p3) { - MutantRunner>* t = + const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2634,77 +2745,77 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1, // 3 - 1 template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1), const P1& p1, const P2& p2, - const P3& p3) { - MutantRunner>* t = + const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2713,40 +2824,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2, - const P3& p3) { - MutantRunner>* t = + const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2754,39 +2865,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2795,40 +2906,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2, - const P3& p3) { - MutantRunner>* t = + const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2836,39 +2947,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2877,41 +2988,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2919,40 +3030,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2961,41 +3072,42 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3003,40 +3115,41 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3045,41 +3158,42 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1, - const P2& p2, const P3& p3) { - MutantRunner>* t = + const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3087,40 +3201,41 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, - A6), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + A6), const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, - A6), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner>* t = + A6), const P1& p1, const P2& p2, const P3& p3) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3129,40 +3244,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4), const P1& p1, const P2& p2, - const P3& p3, const P4& p4) { - MutantRunner>* t = + const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3170,39 +3285,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3211,40 +3326,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2, - const P3& p3, const P4& p4) { - MutantRunner>* t = + const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3252,39 +3367,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3293,41 +3408,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2, - const P3& p3, const P4& p4) { - MutantRunner>* t = + const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3335,40 +3450,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3377,41 +3492,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3419,40 +3534,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3461,41 +3576,42 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3503,40 +3619,41 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3546,27 +3663,28 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1, - const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3574,14 +3692,14 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3590,41 +3708,42 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, - A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, - A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3634,27 +3753,29 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3662,14 +3783,15 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3678,41 +3800,47 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, - A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = - new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = + new Mutant, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = - new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = + new MutantFunction, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, - A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner>* t = - new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor>(t); + A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { + MutantRunner>* t = + new MutantLateObjectBind, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3721,41 +3849,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2, - const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3763,40 +3891,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3805,41 +3933,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2, - const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3847,40 +3975,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3889,41 +4017,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1), template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3931,40 +4059,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3974,27 +4102,28 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4002,14 +4131,14 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4018,41 +4147,42 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4062,27 +4192,28 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4090,14 +4221,14 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4106,43 +4237,44 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, - A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = + A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, - A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = + A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4152,28 +4284,30 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4181,14 +4315,15 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4197,44 +4332,50 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, - A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = - new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = + new Mutant, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = - new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = + new MutantFunction, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, - A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = - new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = + new MutantLateObjectBind, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4244,29 +4385,31 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, - A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = + A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4274,15 +4417,16 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, - A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = + A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4291,45 +4435,51 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, - A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = - new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = + new Mutant, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, - A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = - new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = + new MutantFunction, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, - A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5) { - MutantRunner>* t = - new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor>(t); + A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5) { + MutantRunner>* t = + new MutantLateObjectBind, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4338,41 +4488,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2, - const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4380,42 +4530,42 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1, template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple<>> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple<>> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple<>> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4425,27 +4575,27 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4453,14 +4603,14 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4469,43 +4619,43 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4515,28 +4665,29 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4544,15 +4695,15 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4561,44 +4712,45 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4608,29 +4760,30 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1, - const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner>* t = + const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4638,15 +4791,15 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4655,45 +4808,46 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, - A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, - A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4703,30 +4857,32 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4734,15 +4890,16 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4751,45 +4908,51 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, - A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5, const P6& p6) { - MutantRunner>* t = - new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5, const P6& p6) { + MutantRunner>* t = + new Mutant, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = - new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = + new MutantFunction, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, - A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5, const P6& p6) { - MutantRunner>* t = - new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5, const P6& p6) { + MutantRunner>* t = + new MutantLateObjectBind, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4799,30 +4962,32 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, - A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4830,15 +4995,16 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, - A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4847,45 +5013,51 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, - A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5, const P6& p6) { - MutantRunner>* t = - new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5, const P6& p6) { + MutantRunner>* t = + new Mutant, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, - A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = - new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = + new MutantFunction, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, - A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5, const P6& p6) { - MutantRunner>* t = - new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5, const P6& p6) { + MutantRunner>* t = + new MutantLateObjectBind, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4896,30 +5068,33 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, - A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6), - const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = - new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = + new MutantFunction, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4928,15 +5103,16 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, - A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, - const P6& p6) { - MutantRunner>* t = + A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, + const P6& p6) { + MutantRunner>* t = new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + base::Tuple, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4946,30 +5122,34 @@ template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, - A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5, const P6& p6) { - MutantRunner>* t = - new Mutant, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5, const P6& p6) { + MutantRunner>* t = + new Mutant, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, - A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5, const P6& p6) { - MutantRunner>* t = - new MutantFunction, Tuple> - (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5, const P6& p6) { + MutantRunner>* t = + new MutantFunction, base::Tuple> + (function, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor> +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, - A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, - const P5& p5, const P6& p6) { - MutantRunner>* t = - new MutantLateObjectBind, Tuple> - (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor>(t); + A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, + const P5& p5, const P6& p6) { + MutantRunner>* t = + new MutantLateObjectBind, base::Tuple> + (obj, method, base::MakeTuple(p1, p2, p3, p4, p5, p6)); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) diff --git a/tools/ipc_fuzzer/fuzzer/fuzzer.cc b/tools/ipc_fuzzer/fuzzer/fuzzer.cc index d6e324af64b5a9..58dcf57c0f445f 100644 --- a/tools/ipc_fuzzer/fuzzer/fuzzer.cc +++ b/tools/ipc_fuzzer/fuzzer/fuzzer.cc @@ -209,58 +209,58 @@ struct FuzzTraits { // Specializations for tuples. template <> -struct FuzzTraits> { - static bool Fuzz(Tuple<>* p, Fuzzer* fuzzer) { +struct FuzzTraits> { + static bool Fuzz(base::Tuple<>* p, Fuzzer* fuzzer) { return true; } }; template -struct FuzzTraits> { - static bool Fuzz(Tuple* p, Fuzzer* fuzzer) { - return FuzzParam(&get<0>(*p), fuzzer); +struct FuzzTraits> { + static bool Fuzz(base::Tuple* p, Fuzzer* fuzzer) { + return FuzzParam(&base::get<0>(*p), fuzzer); } }; template -struct FuzzTraits> { - static bool Fuzz(Tuple* p, Fuzzer* fuzzer) { +struct FuzzTraits> { + static bool Fuzz(base::Tuple* p, Fuzzer* fuzzer) { return - FuzzParam(&get<0>(*p), fuzzer) && - FuzzParam(&get<1>(*p), fuzzer); + FuzzParam(&base::get<0>(*p), fuzzer) && + FuzzParam(&base::get<1>(*p), fuzzer); } }; template -struct FuzzTraits> { - static bool Fuzz(Tuple* p, Fuzzer* fuzzer) { +struct FuzzTraits> { + static bool Fuzz(base::Tuple* p, Fuzzer* fuzzer) { return - FuzzParam(&get<0>(*p), fuzzer) && - FuzzParam(&get<1>(*p), fuzzer) && - FuzzParam(&get<2>(*p), fuzzer); + FuzzParam(&base::get<0>(*p), fuzzer) && + FuzzParam(&base::get<1>(*p), fuzzer) && + FuzzParam(&base::get<2>(*p), fuzzer); } }; template -struct FuzzTraits> { - static bool Fuzz(Tuple* p, Fuzzer* fuzzer) { +struct FuzzTraits> { + static bool Fuzz(base::Tuple* p, Fuzzer* fuzzer) { return - FuzzParam(&get<0>(*p), fuzzer) && - FuzzParam(&get<1>(*p), fuzzer) && - FuzzParam(&get<2>(*p), fuzzer) && - FuzzParam(&get<3>(*p), fuzzer); + FuzzParam(&base::get<0>(*p), fuzzer) && + FuzzParam(&base::get<1>(*p), fuzzer) && + FuzzParam(&base::get<2>(*p), fuzzer) && + FuzzParam(&base::get<3>(*p), fuzzer); } }; template -struct FuzzTraits> { - static bool Fuzz(Tuple* p, Fuzzer* fuzzer) { +struct FuzzTraits> { + static bool Fuzz(base::Tuple* p, Fuzzer* fuzzer) { return - FuzzParam(&get<0>(*p), fuzzer) && - FuzzParam(&get<1>(*p), fuzzer) && - FuzzParam(&get<2>(*p), fuzzer) && - FuzzParam(&get<3>(*p), fuzzer) && - FuzzParam(&get<4>(*p), fuzzer); + FuzzParam(&base::get<0>(*p), fuzzer) && + FuzzParam(&base::get<1>(*p), fuzzer) && + FuzzParam(&base::get<2>(*p), fuzzer) && + FuzzParam(&base::get<3>(*p), fuzzer) && + FuzzParam(&base::get<4>(*p), fuzzer); } }; @@ -2053,12 +2053,13 @@ struct FuzzTraits { #define MAX_FAKE_ROUTING_ID 15 #define IPC_MEMBERS_IN_0(p) -#define IPC_MEMBERS_IN_1(p) get<0>(p) -#define IPC_MEMBERS_IN_2(p) get<0>(p), get<1>(p) -#define IPC_MEMBERS_IN_3(p) get<0>(p), get<1>(p), get<2>(p) -#define IPC_MEMBERS_IN_4(p) get<0>(p), get<1>(p), get<2>(p), get<3>(p) -#define IPC_MEMBERS_IN_5(p) get<0>(p), get<1>(p), get<2>(p), get<3>(p), \ - get<4>(p) +#define IPC_MEMBERS_IN_1(p) base::get<0>(p) +#define IPC_MEMBERS_IN_2(p) base::get<0>(p), base::get<1>(p) +#define IPC_MEMBERS_IN_3(p) base::get<0>(p), base::get<1>(p), base::get<2>(p) +#define IPC_MEMBERS_IN_4(p) base::get<0>(p), base::get<1>(p), base::get<2>(p), \ + base::get<3>(p) +#define IPC_MEMBERS_IN_5(p) base::get<0>(p), base::get<1>(p), base::get<2>(p), \ + base::get<3>(p), base::get<4>(p) #define IPC_MEMBERS_OUT_0() #define IPC_MEMBERS_OUT_1() NULL diff --git a/ui/base/win/open_file_name_win.cc b/ui/base/win/open_file_name_win.cc index 167609debcbe37..5e5b5b4c5eedd8 100644 --- a/ui/base/win/open_file_name_win.cc +++ b/ui/base/win/open_file_name_win.cc @@ -85,15 +85,15 @@ OpenFileName::~OpenFileName() { } void OpenFileName::SetFilters( - const std::vector>& filters) { + const std::vector>& filters) { openfilename_.lpstrFilter = NULL; filter_buffer_.clear(); if (filters.empty()) return; for (const auto& filter : filters) { - filter_buffer_.append(get<0>(filter)); + filter_buffer_.append(base::get<0>(filter)); filter_buffer_.push_back(0); - filter_buffer_.append(get<1>(filter)); + filter_buffer_.append(base::get<1>(filter)); filter_buffer_.push_back(0); } filter_buffer_.push_back(0); @@ -202,9 +202,9 @@ void OpenFileName::SetResult(const base::FilePath& directory, } // static -std::vector> +std::vector> OpenFileName::GetFilters(const OPENFILENAME* openfilename) { - std::vector> filters; + std::vector> filters; const base::char16* display_string = openfilename->lpstrFilter; if (!display_string) @@ -219,7 +219,7 @@ OpenFileName::GetFilters(const OPENFILENAME* openfilename) { while (*pattern_end) ++pattern_end; filters.push_back( - MakeTuple(base::string16(display_string, display_string_end), + base::MakeTuple(base::string16(display_string, display_string_end), base::string16(pattern, pattern_end))); display_string = pattern_end + 1; } diff --git a/ui/base/win/open_file_name_win.h b/ui/base/win/open_file_name_win.h index 1a3aab54cd96d0..596b1470f5f88d 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>& filters); + const std::vector>& 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> GetFilters( + static std::vector> 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 d359d9d962a90e..e63df7d0e9a9fb 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>& expected, - const std::vector>& actual) { + const std::vector>& expected, + const std::vector>& actual) { if (expected.size() != actual.size()) { ADD_FAILURE() << "filter count mismatch. Got " << actual.size() << " expected " << expected.size() << "."; @@ -36,9 +36,9 @@ void CheckFilters( } for (size_t i = 0; i < expected.size(); ++i) { - EXPECT_EQ(get<0>(expected[i]), get<0>(actual[i])) + EXPECT_EQ(base::get<0>(expected[i]), base::get<0>(actual[i])) << "Mismatch at index " << i; - EXPECT_EQ(get<1>(expected[i]), get<1>(actual[i])) + EXPECT_EQ(base::get<1>(expected[i]), base::get<1>(actual[i])) << "Mismatch at index " << i; } } @@ -203,19 +203,19 @@ TEST(OpenFileNameTest, SetAndGetFilters) { const base::string16 kNull(L"\0", 1); ui::win::OpenFileName ofn(kHwnd, kFlags); - std::vector> filters; + std::vector> filters; ofn.SetFilters(filters); EXPECT_FALSE(ofn.GetOPENFILENAME()->lpstrFilter); CheckFilters(filters, ui::win::OpenFileName::GetFilters(ofn.GetOPENFILENAME())); - filters.push_back(MakeTuple(base::string16(L"a"), base::string16(L"b"))); + filters.push_back(base::MakeTuple(base::string16(L"a"), base::string16(L"b"))); ofn.SetFilters(filters); CheckFilterString(L"a" + kNull + L"b" + kNull, ofn); CheckFilters(filters, ui::win::OpenFileName::GetFilters(ofn.GetOPENFILENAME())); - filters.push_back(MakeTuple(base::string16(L"X"), base::string16(L"Y"))); + filters.push_back(base::MakeTuple(base::string16(L"X"), base::string16(L"Y"))); ofn.SetFilters(filters); CheckFilterString(L"a" + kNull + L"b" + kNull + L"X" + kNull + L"Y" + kNull, ofn); diff --git a/ui/ozone/platform/drm/gpu/drm_gpu_platform_support.cc b/ui/ozone/platform/drm/gpu/drm_gpu_platform_support.cc index e546bf2ed03c93..b8b1b79c7e8576 100644 --- a/ui/ozone/platform/drm/gpu/drm_gpu_platform_support.cc +++ b/ui/ozone/platform/drm/gpu/drm_gpu_platform_support.cc @@ -150,7 +150,7 @@ class DrmGpuPlatformSupportMessageFilter : public IPC::MessageFilter { if (!OzoneGpuMsg_CursorSet::Read(&message, ¶m)) return; - int frame_delay_ms = get<3>(param); + int frame_delay_ms = base::get<3>(param); cursor_animating_ = frame_delay_ms != 0; } diff --git a/ui/shell_dialogs/select_file_dialog_win.cc b/ui/shell_dialogs/select_file_dialog_win.cc index 2ada0ce1f69b22..bf0d30b085f9d4 100644 --- a/ui/shell_dialogs/select_file_dialog_win.cc +++ b/ui/shell_dialogs/select_file_dialog_win.cc @@ -514,12 +514,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> filters = + std::vector> filters = ui::win::OpenFileName::GetFilters(save_as.GetOPENFILENAME()); if (*index > filters.size()) NOTREACHED() << "Invalid filter index."; else - filter_selected = get<1>(filters[*index - 1]); + filter_selected = base::get<1>(filters[*index - 1]); } // Get the extension that was suggested to the user (when the Save As dialog