Move helper_gmock.h from ChromFrame subrtee to testing directory....

chrome_frame/test/helper_gmock.h

Index: chrome_frame/test/helper_gmock.h
===================================================================
--- chrome_frame/test/helper_gmock.h	(revision 29410)
+++ chrome_frame/test/helper_gmock.h	(working copy)
@@ -1,627 +0,0 @@
-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-#ifndef CHROME_FRAME_TEST_HELPER_GMOCK_H_
-#define CHROME_FRAME_TEST_HELPER_GMOCK_H_
-// The intention of this file is to make possible using GMock actions in
-// all of its syntactic beauty. Classes and helper functions could be used as
-// more generic variants of Task and Callback classes (see base/task.h)
-// Mutant supports both pre-bound arguments (like Task) and call-time arguments
-// (like Callback) - hence the name. :-)
-// DispatchToMethod supporting two sets of arguments -
-// pre-bound (P) and call-time (C) as well as return value type is templatized
-// It will also try to call the selected method even if provided pre-bound args
-// does not match exactly with the function signature - hence the X1, X2
-// parameters in CreateFunctor.
-
-#include "base/linked_ptr.h"
-#include "base/task.h"   // for CallBackStorage
-#include "base/tuple.h"  // for Tuple
-
-
-// 0 - 0
-template <typename R, typename T, typename Method>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple0& c) {
-  return (obj->*method)();
-}
-
-// 0 - 1
-template <typename R, typename T, typename Method, typename C1>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(c.a);
-}
-
-// 0 - 2
-template <typename R, typename T, typename Method, typename C1, typename C2>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(c.a, c.b);
-}
-
-// 0 - 3
-template <typename R, typename T, typename Method, typename C1, typename C2,
-          typename C3>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(c.a, c.b, c.c);
-}
-
-// 0 - 4
-template <typename R, typename T, typename Method, typename C1, typename C2,
-          typename C3, typename C4>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple0& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(c.a, c.b, c.c, c.d);
-}
-
-// 1 - 0
-template <typename R, typename T, typename Method, typename P1>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a);
-}
-
-// 1 - 1
-template <typename R, typename T, typename Method, typename P1, typename C1>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, c.a);
-}
-
-// 1 - 2
-template <typename R, typename T, typename Method, typename P1, typename C1,
-          typename C2>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, c.a, c.b);
-}
-
-// 1 - 3
-template <typename R, typename T, typename Method, typename P1, typename C1,
-          typename C2, typename C3>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, c.a, c.b, c.c);
-}
-
-// 1 - 4
-template <typename R, typename T, typename Method, typename P1, typename C1,
-          typename C2, typename C3, typename C4>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple1<P1>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, c.a, c.b, c.c, c.d);
-}
-
-// 2 - 0
-template <typename R, typename T, typename Method, typename P1, typename P2>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a, p.b);
-}
-
-// 2 - 1
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename C1>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, p.b, c.a);
-}
-
-// 2 - 2
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename C1, typename C2>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, p.b, c.a, c.b);
-}
-
-// 2 - 3
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename C1, typename C2, typename C3>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, p.b, c.a, c.b, c.c);
-}
-
-// 2 - 4
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename C1, typename C2, typename C3, typename C4>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple2<P1, P2>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d);
-}
-
-// 3 - 0
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a, p.b, p.c);
-}
-
-// 3 - 1
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename C1>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a);
-}
-
-// 3 - 2
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename C1, typename C2>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a, c.b);
-}
-
-// 3 - 3
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename C1, typename C2, typename C3>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c);
-}
-
-// 3 - 4
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename C1, typename C2, typename C3, typename C4>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple3<P1, P2, P3>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d);
-}
-
-// 4 - 0
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename P4>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple0& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d);
-}
-
-// 4 - 1
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename P4, typename C1>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple1<C1>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a);
-}
-
-// 4 - 2
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename P4, typename C1, typename C2>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple2<C1, C2>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b);
-}
-
-// 4 - 3
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename P4, typename C1, typename C2, typename C3>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple3<C1, C2, C3>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c);
-}
-
-// 4 - 4
-template <typename R, typename T, typename Method, typename P1, typename P2,
-          typename P3, typename P4, typename C1, typename C2, typename C3,
-          typename C4>
-inline R DispatchToMethod(T* obj, Method method,
-                          const Tuple4<P1, P2, P3, P4>& p,
-                          const Tuple4<C1, C2, C3, C4>& c) {
-  return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d);
-}
-
-// Interface that is exposed to the consumer, that does the actual calling
-// of the method.
-template <typename R, typename Params>
-class MutantRunner {
- public:
-  virtual R RunWithParams(const Params& params) = 0;
-  virtual ~MutantRunner() {}
-};
-
-// MutantImpl holds pre-bound arguments (like Task) and like Callback
-// allows call-time arguments.
-template <typename R, typename T, typename Method,
-                      typename PreBound, typename Params>
-class MutantImpl : public CallbackStorage<T, Method>,
-                   public MutantRunner<R, Params> {
- public:
-  MutantImpl(T* obj, Method meth, const PreBound& pb)
-    : CallbackStorage<T, Method>(obj, meth),
-    pb_(pb) {
-  }
-
-  // MutantRunner implementation
-  virtual R RunWithParams(const Params& params) {
-    return DispatchToMethod<R>(this->obj_, this->meth_, pb_, params);
-  }
-
-  PreBound pb_;
-};
-
-// Simple MutantRunner<> wrapper acting as a functor.
-// Redirects operator() to MutantRunner<Params>::Run()
-template <typename R, typename Params>
-struct MutantFunctor {
-  explicit MutantFunctor(MutantRunner<R, Params>*  cb) : impl_(cb) {
-  }
-
-  ~MutantFunctor() {
-  }
-
-  inline R operator()() {
-    return impl_->RunWithParams(Tuple0());
-  }
-
-  template <typename Arg1>
-  inline R operator()(const Arg1& a) {
-    return impl_->RunWithParams(Params(a));
-  }
-
-  template <typename Arg1, typename Arg2>
-  inline R operator()(const Arg1& a, const Arg2& b) {
-    return impl_->RunWithParams(Params(a, b));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3>
-  inline R operator()(const Arg1& a, const Arg2& b, const Arg3& c) {
-    return impl_->RunWithParams(Params(a, b, c));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-  inline R operator()(const Arg1& a, const Arg2& b, const Arg3& c,
-                         const Arg4& d) {
-    return impl_->RunWithParams(Params(a, b, c, d));
-  }
-
- private:
-  // We need copy constructor since MutantFunctor is copied few times
-  // inside GMock machinery, hence no DISALLOW_EVIL_CONTRUCTORS
-  MutantFunctor();
-  linked_ptr<MutantRunner<R, Params> > impl_;
-};
-
-
-
-// 0 - 0
-template <typename R, typename T>
-inline MutantFunctor<R, Tuple0>
-CreateFunctor(T* obj, R (T::*method)()) {
-  MutantRunner<R, Tuple0> *t = new MutantImpl<R, T,
-      R (T::*)(),
-      Tuple0, Tuple0>
-      (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple0>(t);
-}
-
-// 0 - 1
-template <typename R, typename T, typename A1>
-inline MutantFunctor<R, Tuple1<A1> >
-CreateFunctor(T* obj, R (T::*method)(A1)) {
-  MutantRunner<R, Tuple1<A1> > *t = new MutantImpl<R, T,
-      R (T::*)(A1),
-      Tuple0, Tuple1<A1> >
-      (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple1<A1> >(t);
-}
-
-// 0 - 2
-template <typename R, typename T, typename A1, typename A2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
-CreateFunctor(T* obj, R (T::*method)(A1, A2)) {
-  MutantRunner<R, Tuple2<A1, A2> > *t = new MutantImpl<R, T,
-      R (T::*)(A1, A2),
-      Tuple0, Tuple2<A1, A2> >
-      (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
-}
-
-// 0 - 3
-template <typename R, typename T, typename A1, typename A2, typename A3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
-CreateFunctor(T* obj, R (T::*method)(A1, A2, A3)) {
-  MutantRunner<R, Tuple3<A1, A2, A3> > *t = new MutantImpl<R, T,
-      R (T::*)(A1, A2, A3),
-      Tuple0, Tuple3<A1, A2, A3> >
-      (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
-}
-
-// 0 - 4
-template <typename R, typename T, typename A1, typename A2, typename A3,
-          typename A4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
-CreateFunctor(T* obj, R (T::*method)(A1, A2, A3, A4)) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> > *t = new MutantImpl<R, T,
-      R (T::*)(A1, A2, A3, A4),
-      Tuple0, Tuple4<A1, A2, A3, A4> >
-      (obj, method, MakeTuple());
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
-}
-
-// 1 - 0
-template <typename R, typename T, typename P1, typename X1>
-inline MutantFunctor<R, Tuple0>
-CreateFunctor(T* obj, R (T::*method)(X1), const P1& p1) {
-  MutantRunner<R, Tuple0> *t = new MutantImpl<R, T,
-      R (T::*)(X1),
-      Tuple1<P1>, Tuple0>
-      (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple0>(t);
-}
-
-// 1 - 1
-template <typename R, typename T, typename P1, typename A1, typename X1>
-inline MutantFunctor<R, Tuple1<A1> >
-CreateFunctor(T* obj, R (T::*method)(X1, A1), const P1& p1) {
-  MutantRunner<R, Tuple1<A1> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, A1),
-      Tuple1<P1>, Tuple1<A1> >
-      (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple1<A1> >(t);
-}
-
-// 1 - 2
-template <typename R, typename T, typename P1, typename A1, typename A2,
-          typename X1>
-inline MutantFunctor<R, Tuple2<A1, A2> >
-CreateFunctor(T* obj, R (T::*method)(X1, A1, A2), const P1& p1) {
-  MutantRunner<R, Tuple2<A1, A2> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, A1, A2),
-      Tuple1<P1>, Tuple2<A1, A2> >
-      (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
-}
-
-// 1 - 3
-template <typename R, typename T, typename P1, typename A1, typename A2,
-          typename A3, typename X1>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
-CreateFunctor(T* obj, R (T::*method)(X1, A1, A2, A3), const P1& p1) {
-  MutantRunner<R, Tuple3<A1, A2, A3> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, A1, A2, A3),
-      Tuple1<P1>, Tuple3<A1, A2, A3> >
-      (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
-}
-
-// 1 - 4
-template <typename R, typename T, typename P1, typename A1, typename A2,
-          typename A3, typename A4, typename X1>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
-CreateFunctor(T* obj, R (T::*method)(X1, A1, A2, A3, A4), const P1& p1) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, A1, A2, A3, A4),
-      Tuple1<P1>, Tuple4<A1, A2, A3, A4> >
-      (obj, method, MakeTuple(p1));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
-}
-
-// 2 - 0
-template <typename R, typename T, typename P1, typename P2, typename X1,
-          typename X2>
-inline MutantFunctor<R, Tuple0>
-CreateFunctor(T* obj, R (T::*method)(X1, X2), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple0> *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2),
-      Tuple2<P1, P2>, Tuple0>
-      (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple0>(t);
-}
-
-// 2 - 1
-template <typename R, typename T, typename P1, typename P2, typename A1,
-          typename X1, typename X2>
-inline MutantFunctor<R, Tuple1<A1> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, A1), const P1& p1, const P2& p2) {
-  MutantRunner<R, Tuple1<A1> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, A1),
-      Tuple2<P1, P2>, Tuple1<A1> >
-      (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple1<A1> >(t);
-}
-
-// 2 - 2
-template <typename R, typename T, typename P1, typename P2, typename A1,
-          typename A2, typename X1, typename X2>
-inline MutantFunctor<R, Tuple2<A1, A2> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, A1, A2), const P1& p1,
-    const P2& p2) {
-  MutantRunner<R, Tuple2<A1, A2> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, A1, A2),
-      Tuple2<P1, P2>, Tuple2<A1, A2> >
-      (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
-}
-
-// 2 - 3
-template <typename R, typename T, typename P1, typename P2, typename A1,
-          typename A2, typename A3, typename X1, typename X2>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, A1, A2, A3), const P1& p1,
-    const P2& p2) {
-  MutantRunner<R, Tuple3<A1, A2, A3> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, A1, A2, A3),
-      Tuple2<P1, P2>, Tuple3<A1, A2, A3> >
-      (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
-}
-
-// 2 - 4
-template <typename R, typename T, typename P1, typename P2, typename A1,
-          typename A2, typename A3, typename A4, typename X1, typename X2>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, A1, A2, A3, A4), const P1& p1,
-    const P2& p2) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, A1, A2, A3, A4),
-      Tuple2<P1, P2>, Tuple4<A1, A2, A3, A4> >
-      (obj, method, MakeTuple(p1, p2));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
-}
-
-// 3 - 0
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple0>
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3), const P1& p1, const P2& p2,
-    const P3& p3) {
-  MutantRunner<R, Tuple0> *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3),
-      Tuple3<P1, P2, P3>, Tuple0>
-      (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple0>(t);
-}
-
-// 3 - 1
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename A1, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple1<A1> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, A1), const P1& p1,
-    const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple1<A1> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, A1),
-      Tuple3<P1, P2, P3>, Tuple1<A1> >
-      (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple1<A1> >(t);
-}
-
-// 3 - 2
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename A1, typename A2, typename X1, typename X2, typename X3>
-inline MutantFunctor<R, Tuple2<A1, A2> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, A1, A2), const P1& p1,
-    const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple2<A1, A2> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, A1, A2),
-      Tuple3<P1, P2, P3>, Tuple2<A1, A2> >
-      (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
-}
-
-// 3 - 3
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename A1, typename A2, typename A3, typename X1, typename X2,
-          typename X3>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, A1, A2, A3), const P1& p1,
-    const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple3<A1, A2, A3> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, A1, A2, A3),
-      Tuple3<P1, P2, P3>, Tuple3<A1, A2, A3> >
-      (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
-}
-
-// 3 - 4
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename A1, typename A2, typename A3, typename A4, typename X1,
-          typename X2, typename X3>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1,
-    const P2& p2, const P3& p3) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, A1, A2, A3, A4),
-      Tuple3<P1, P2, P3>, Tuple4<A1, A2, A3, A4> >
-      (obj, method, MakeTuple(p1, p2, p3));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
-}
-
-// 4 - 0
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename P4, typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple0>
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, X4), const P1& p1,
-    const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple0> *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, X4),
-      Tuple4<P1, P2, P3, P4>, Tuple0>
-      (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple0>(t);
-}
-
-// 4 - 1
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename P4, typename A1, typename X1, typename X2, typename X3,
-          typename X4>
-inline MutantFunctor<R, Tuple1<A1> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, X4, A1), const P1& p1,
-    const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple1<A1> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, X4, A1),
-      Tuple4<P1, P2, P3, P4>, Tuple1<A1> >
-      (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple1<A1> >(t);
-}
-
-// 4 - 2
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename P4, typename A1, typename A2, typename X1, typename X2,
-          typename X3, typename X4>
-inline MutantFunctor<R, Tuple2<A1, A2> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, X4, A1, A2), const P1& p1,
-    const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple2<A1, A2> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, X4, A1, A2),
-      Tuple4<P1, P2, P3, P4>, Tuple2<A1, A2> >
-      (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple2<A1, A2> >(t);
-}
-
-// 4 - 3
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename P4, typename A1, typename A2, typename A3, typename X1,
-          typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple3<A1, A2, A3> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1,
-    const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple3<A1, A2, A3> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, X4, A1, A2, A3),
-      Tuple4<P1, P2, P3, P4>, Tuple3<A1, A2, A3> >
-      (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple3<A1, A2, A3> >(t);
-}
-
-// 4 - 4
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename P4, typename A1, typename A2, typename A3, typename A4,
-          typename X1, typename X2, typename X3, typename X4>
-inline MutantFunctor<R, Tuple4<A1, A2, A3, A4> >
-CreateFunctor(T* obj, R (T::*method)(X1, X2, X3, X4, A1, A2, A3, A4),
-    const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
-  MutantRunner<R, Tuple4<A1, A2, A3, A4> > *t = new MutantImpl<R, T,
-      R (T::*)(X1, X2, X3, X4, A1, A2, A3, A4),
-      Tuple4<P1, P2, P3, P4>, Tuple4<A1, A2, A3, A4> >
-      (obj, method, MakeTuple(p1, p2, p3, p4));
-  return MutantFunctor<R, Tuple4<A1, A2, A3, A4> >(t);
-}
-#endif  // CHROME_FRAME_TEST_HELPER_GMOCK_H_