FBTF: Move ctors/dtors into implementation files. Adds ctors/dtors to non-POD structs.

base/simple_thread.h

 // Copyright (c) 2006-2008 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.
 
 // WARNING: You should probably be using Thread (thread.h) instead.  Thread is
 //          Chrome's message-loop based Thread abstraction, and if you are a
 //          thread running in the browser, there will likely be assumptions
 //          that your thread will have an associated message loop.
 //
 // This is a simple thread interface that backs to a native operating system
@@ skipping 56 matching lines @@
     void set_stack_size(size_t size) { stack_size_ = size; }
     size_t stack_size() const { return stack_size_; }
    private:
     size_t stack_size_;
   };
 
   // Create a SimpleThread.  |options| should be used to manage any specific
   // configuration involving the thread creation and management.
   // Every thread has a name, in the form of |name_prefix|/TID, for example
   // "my_thread/321".  The thread will not be created until Start() is called.
-  explicit SimpleThread(const std::string& name_prefix)
-      : name_prefix_(name_prefix), name_(name_prefix),
-        thread_(), event_(true, false), tid_(0), joined_(false) { }
-  SimpleThread(const std::string& name_prefix, const Options& options)
-      : name_prefix_(name_prefix), name_(name_prefix), options_(options),
-        thread_(), event_(true, false), tid_(0), joined_(false) { }
+  explicit SimpleThread(const std::string& name_prefix);
+  SimpleThread(const std::string& name_prefix, const Options& options);
 
   virtual ~SimpleThread();
 
   virtual void Start();
   virtual void Join();
 
   // We follow the PlatformThread Delegate interface.
   virtual void ThreadMain();
 
   // Subclasses should override the Run method.
@@ skipping 27 matching lines @@
 class DelegateSimpleThread : public SimpleThread {
  public:
   class Delegate {
    public:
     Delegate() { }
     virtual ~Delegate() { }
     virtual void Run() = 0;
   };
 
   DelegateSimpleThread(Delegate* delegate,
-                       const std::string& name_prefix)
-      : SimpleThread(name_prefix), delegate_(delegate) { }
+                       const std::string& name_prefix);
   DelegateSimpleThread(Delegate* delegate,
                        const std::string& name_prefix,
-                       const Options& options)
-      : SimpleThread(name_prefix, options), delegate_(delegate) { }
+                       const Options& options);
 
-  virtual ~DelegateSimpleThread() { }
+  virtual ~DelegateSimpleThread();
   virtual void Run();
  private:
   Delegate* delegate_;
 };
 
 // DelegateSimpleThreadPool allows you to start up a fixed number of threads,
 // and then add jobs which will be dispatched to the threads.  This is
 // convenient when you have a lot of small work that you want done
 // multi-threaded, but don't want to spawn a thread for each small bit of work.
 //
 // You just call AddWork() to add a delegate to the list of work to be done.
 // JoinAll() will make sure that all outstanding work is processed, and wait
 // for everything to finish.  You can reuse a pool, so you can call Start()
 // again after you've called JoinAll().
 class DelegateSimpleThreadPool : public DelegateSimpleThread::Delegate {
  public:
   typedef DelegateSimpleThread::Delegate Delegate;
 
-  DelegateSimpleThreadPool(const std::string& name_prefix, int num_threads)
-      : name_prefix_(name_prefix), num_threads_(num_threads),
-        dry_(true, false) { }
-  ~DelegateSimpleThreadPool();
+  DelegateSimpleThreadPool(const std::string& name_prefix, int num_threads);
+  virtual ~DelegateSimpleThreadPool();
 
   // Start up all of the underlying threads, and start processing work if we
   // have any.
   void Start();
 
   // Make sure all outstanding work is finished, and wait for and destroy all
   // of the underlying threads in the pool.
   void JoinAll();
 
   // It is safe to AddWork() any time, before or after Start().
@@ skipping 11 matching lines @@
   int num_threads_;
   std::vector<DelegateSimpleThread*> threads_;
   std::queue<Delegate*> delegates_;
   Lock lock_;            // Locks delegates_
   WaitableEvent dry_;    // Not signaled when there is no work to do.
 };
 
 }  // namespace base
 
 #endif  // BASE_SIMPLE_THREAD_H_