Base: First pass at having base.dll: definition of

base/synchronization/lock.h

 // 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_SYNCHRONIZATION_LOCK_H_
 #define BASE_SYNCHRONIZATION_LOCK_H_
 #pragma once
 
+#include "base/base_api.h"
 #include "base/synchronization/lock_impl.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 
 // A convenient wrapper for an OS specific critical section.  The only real
 // intelligence in this class is in debug mode for the support for the
 // AssertAcquired() method.
-class Lock {
+class BASE_API Lock {

[wtc, 2011/03/23 22:05:12]

Can you summarize the rules for determining which classes
and functions need BASE_API.

I noticed that inline functions do not need BASE_API.

For classes, I don't know what the rules are.  This file
is a good example.  Why don't the AutoLock and AutoUnlock
classes need BASE_API?  Is it also because they can be
inlined?

[rvargas (doing something else), 2011/03/23 22:59:04]

The basic rule is that anything that is not directly visible to the compiler has
to be exported. In other words, code implemented on cc files, or on files that
are not directly included.

Exporting a class exposes all public members, but not the private ones. Classes
defined as part of the public interface of a class also have to be exported.

At the end of the day, there may be cases where the unit test requires more
stuff than really needed (internal details), or is not testing parts of the code
that also have to be exported when they are used by other modules; but we'll
only find out about that when trying to build everything.

In the AutoLock example, we'll end up with multiple versions of the code, one on
each module (base/net/chrome etc). As long as there are no static members (or
there's no real issue with having multiple copies on the same process),
everything should be fine.

  public:
 #if defined(NDEBUG)             // Optimized wrapper implementation
   Lock() : lock_() {}
   ~Lock() {}
   void Acquire() { lock_.Lock(); }
   void Release() { lock_.Unlock(); }
 
   // If the lock is not held, take it and return true. If the lock is already
   // held by another thread, immediately return false. This must not be called
   // by a thread already holding the lock (what happens is undefined and an
@@ skipping 94 matching lines @@
   }
 
  private:
   Lock& lock_;
   DISALLOW_COPY_AND_ASSIGN(AutoUnlock);
 };
 
 }  // namespace base
 
 #endif  // BASE_SYNCHRONIZATION_LOCK_H_