Callback: De-inline CallbackBase, and move to callback_helpers -> callback_internal.h

base/callback.h

 // This file was GENERATED by command:
 //     pump.py callback.h.pump
 // DO NOT EDIT BY HAND!!!
 
 
 // Copyright (c) 2011 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 BASE_CALLBACK_H_
 #define BASE_CALLBACK_H_
 #pragma once
 
-#include "base/callback_helpers.h"
+#include "base/callback_internal.h"
 #include "base/callback_old.h"
 
 // New, super-duper, unified Callback system.  This will eventually replace
 // NewRunnableMethod, NewRunnableFunction, CreateFunctor, and CreateCallback
 // systems currently in the Chromium code base.
 //
 // WHAT IS THIS:
 //
 // The templated Callback class is a generalized function object. Together
 // with the Bind() function in bind.h, they provide a type-safe method for
@@ skipping 180 matching lines @@
 //  - Invoking the return of Bind.  Bind(&foo).Run() does not work;
 //  - Binding arrays to functions that take a non-const pointer.
 //    Example:
 //      void Foo(const char* ptr);
 //      void Bar(char* ptr);
 //      Bind(&Foo, "test");
 //      Bind(&Bar, "test");  // This fails because ptr is not const.
 
 namespace base {
 
-namespace internal {
-
-// Holds the methods that don't require specialization to reduce template bloat.
-class CallbackBase {
- public:
-  // Returns true if Callback is null (doesn't refer to anything).
-  bool is_null() const {
-    return invoker_storage_.get() == NULL;
-  }
-
-  // Returns the Callback into an uninitalized state.
-  void Reset() {
-    invoker_storage_ = NULL;
-    polymorphic_invoke_ = NULL;
-  }
-
-  bool Equals(const CallbackBase& other) const {
-    return invoker_storage_.get() == other.invoker_storage_.get() &&
-           polymorphic_invoke_ == other.polymorphic_invoke_;
-  }
-
- protected:
-  // In C++, it is safe to cast function pointers to function pointers of
-  // another type. It is not okay to use void*. We create a InvokeFuncStorage
-  // that that can store our function pointer, and then cast it back to
-  // the original type on usage.
-  typedef void(*InvokeFuncStorage)(void);
-
-  CallbackBase(InvokeFuncStorage polymorphic_invoke,
-               scoped_refptr<InvokerStorageBase>* invoker_storage)
-      : polymorphic_invoke_(polymorphic_invoke) {
-    if (invoker_storage) {
-      invoker_storage_.swap(*invoker_storage);
-    }
-  }
-
-  scoped_refptr<InvokerStorageBase> invoker_storage_;
-  InvokeFuncStorage polymorphic_invoke_;
-};
-
-}  // namespace internal
-
-
 // First, we forward declare the Callback class template. This informs the
 // compiler that the template only has 1 type parameter which is the function
 // signature that the Callback is representing.
 //
 // After this, create template specializations for 0-6 parameters. Note that
 // even though the template typelist grows, the specialization still
 // only has one type: the function signature.
 template <typename Sig>
 class Callback;
 template <typename R>
@@ skipping 247 matching lines @@
 };
 
 
 // Syntactic sugar to make Callbacks<void(void)> easier to declare since it
 // will be used in a lot of APIs with delayed execution.
 typedef Callback<void(void)> Closure;
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_H