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

This reverts commit r75443.

TBR=akalin

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@75445 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 44 insertions, 1 deletions

diff --git a/base/callback.h b/base/callback.h
index 9c76aa5..9e43afb 100644
--- a/base/callback.h
+++ b/base/callback.h
@@ -11,7 +11,7 @@
 #define BASE_CALLBACK_H_
 #pragma once
 
-#include "base/callback_internal.h"
+#include "base/callback_helpers.h"
 #include "base/callback_old.h"
 
 // New, super-duper, unified Callback system.  This will eventually replace
@@ -212,6 +212,49 @@
 
 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.