Move implementation from header to source.

base/task.h

 // Copyright (c) 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 BASE_TASK_H_
 #define BASE_TASK_H_
 
 #include "base/non_thread_safe.h"
 #include "base/raw_scoped_refptr_mismatch_checker.h"
 #include "base/tracked.h"
 #include "base/tuple.h"
 #include "base/weak_ptr.h"
 
 // Task ------------------------------------------------------------------------
 //
 // A task is a generic runnable thingy, usually used for running code on a
 // different thread or for scheduling future tasks off of the message loop.
 
 class Task : public tracked_objects::Tracked {
  public:
-  Task() {}
-  virtual ~Task() {}
+  Task();
+  virtual ~Task();
 
   // Tasks are automatically deleted after Run is called.
   virtual void Run() = 0;
 };
 
 class CancelableTask : public Task {
  public:
+  CancelableTask();
+  ~CancelableTask();

[Evan Martin, 2010/07/15 17:37:33]

Why are these needed?
Should this be virtual?

[Elliot Glaysher, 2010/07/15 18:08:10]

Because a copy of the synthesized constructor/destructor is still emitted in the
resulting object files. Task()/~Task()/CancelableTask()/~CancelableTask() were
some of the hotspots that showed up when I did my big script to find the most
commonly included weak symbols.
Done.

+
   // Not all tasks support cancellation.
   virtual void Cancel() = 0;
 };
 
 // Scoped Factories ------------------------------------------------------------
 //
 // These scoped factory objects can be used by non-refcounted objects to safely
 // place tasks in a message loop.  Each factory guarantees that the tasks it
 // produces will not run after the factory is destroyed.  Commonly, factories
 // are declared as class members, so the class' tasks will automatically cancel
@@ skipping 441 matching lines @@
                                            const A& a, const B& b,
                                            const C& c, const D& d,
                                            const E& e) {
   return new RunnableFunction<Function, Tuple5<A, B, C, D, E> >(function,
                                                                 MakeTuple(a, b,
                                                                           c, d,
                                                                           e));
 }
 
 #endif  // BASE_TASK_H_