diff options
| author | darin@chromium.org <darin@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2011-08-05 15:34:00 +0000 |
|---|---|---|
| committer | darin@chromium.org <darin@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2011-08-05 15:34:00 +0000 |
| commit | 0bea7254836d17e3f1e278cbd52e8b8816c49a48 (patch) | |
| tree | eb16c01ad0143fad583cd60a87828fd90c94f61a /base | |
| parent | 93f3edc8adc1db9e3d1deebde0ec58d15b7e1a91 (diff) | |
| download | chromium_src-0bea7254836d17e3f1e278cbd52e8b8816c49a48.zip chromium_src-0bea7254836d17e3f1e278cbd52e8b8816c49a48.tar.gz chromium_src-0bea7254836d17e3f1e278cbd52e8b8816c49a48.tar.bz2 | |
Rename BASE_API to BASE_EXPORT.
R=rvargas
Review URL: http://codereview.chromium.org/7461141
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@95618 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'base')
126 files changed, 978 insertions, 950 deletions
diff --git a/base/at_exit.h b/base/at_exit.h index 06214d1..9e75a3f 100644 --- a/base/at_exit.h +++ b/base/at_exit.h @@ -8,7 +8,7 @@ #include <stack> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/synchronization/lock.h" @@ -28,7 +28,7 @@ namespace base { // When the exit_manager object goes out of scope, all the registered // callbacks and singleton destructors will be called. -class BASE_API AtExitManager { +class BASE_EXPORT AtExitManager { public: typedef void (*AtExitCallbackType)(void*); diff --git a/base/atomicops_internals_x86_gcc.h b/base/atomicops_internals_x86_gcc.h index 297727e..72fd350 100644 --- a/base/atomicops_internals_x86_gcc.h +++ b/base/atomicops_internals_x86_gcc.h @@ -8,10 +8,10 @@ #define BASE_ATOMICOPS_INTERNALS_X86_GCC_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" // This struct is not part of the public API of this module; clients may not -// use it. (However, it's exported via BASE_API because clients implicitly +// use it. (However, it's exported via BASE_EXPORT because clients implicitly // do use it at link time by inlining these functions.) // Features of this x86. Values may not be correct before main() is run, // but are set conservatively. @@ -20,7 +20,7 @@ struct AtomicOps_x86CPUFeatureStruct { // after acquire compare-and-swap. bool has_sse2; // Processor has SSE2. }; -BASE_API extern struct AtomicOps_x86CPUFeatureStruct +BASE_EXPORT extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures; #define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory") diff --git a/base/base.gypi b/base/base.gypi index c35b344..ac53560 100644 --- a/base/base.gypi +++ b/base/base.gypi @@ -26,7 +26,7 @@ 'atomicops.h', 'atomicops_internals_x86_gcc.cc', 'atomicops_internals_x86_msvc.h', - 'base_api.h', + 'base_export.h', 'base_paths.cc', 'base_paths.h', 'base_paths_mac.h', diff --git a/base/base64.h b/base/base64.h index e966ea7..df7dc16 100644 --- a/base/base64.h +++ b/base/base64.h @@ -8,18 +8,18 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string_piece.h" namespace base { // Encodes the input string in base64. Returns true if successful and false // otherwise. The output string is only modified if successful. -BASE_API bool Base64Encode(const StringPiece& input, std::string* output); +BASE_EXPORT bool Base64Encode(const StringPiece& input, std::string* output); // Decodes the base64 input string. Returns true if successful and false // otherwise. The output string is only modified if successful. -BASE_API bool Base64Decode(const StringPiece& input, std::string* output); +BASE_EXPORT bool Base64Decode(const StringPiece& input, std::string* output); } // namespace base diff --git a/base/base_api.h b/base/base_export.h index deeae07..de3ec26 100644 --- a/base/base_api.h +++ b/base/base_export.h @@ -2,25 +2,25 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef BASE_BASE_API_H_ -#define BASE_BASE_API_H_ +#ifndef BASE_BASE_EXPORT_H_ +#define BASE_BASE_EXPORT_H_ #pragma once #if defined(COMPONENT_BUILD) #if defined(WIN32) #if defined(BASE_IMPLEMENTATION) -#define BASE_API __declspec(dllexport) +#define BASE_EXPORT __declspec(dllexport) #else -#define BASE_API __declspec(dllimport) +#define BASE_EXPORT __declspec(dllimport) #endif // defined(BASE_IMPLEMENTATION) #else // defined(WIN32) -#define BASE_API __attribute__((visibility("default"))) +#define BASE_EXPORT __attribute__((visibility("default"))) #endif #else // defined(COMPONENT_BUILD) -#define BASE_API +#define BASE_EXPORT #endif -#endif // BASE_BASE_API_H_ +#endif // BASE_BASE_EXPORT_H_ diff --git a/base/callback_internal.h b/base/callback_internal.h index b83b049..1543eca 100644 --- a/base/callback_internal.h +++ b/base/callback_internal.h @@ -11,7 +11,7 @@ #include <stddef.h> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/memory/ref_counted.h" namespace base { @@ -54,7 +54,7 @@ InvokerStorageHolder<T> MakeInvokerStorageHolder(T* o) { // Holds the Callback methods that don't require specialization to reduce // template bloat. -class BASE_API CallbackBase { +class BASE_EXPORT CallbackBase { public: // Returns true if Callback is null (doesn't refer to anything). bool is_null() const; diff --git a/base/command_line.h b/base/command_line.h index 3b15e93..a932a05 100644 --- a/base/command_line.h +++ b/base/command_line.h @@ -21,12 +21,12 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "build/build_config.h" class FilePath; -class BASE_API CommandLine { +class BASE_EXPORT CommandLine { public: #if defined(OS_WIN) // The native command line string type. @@ -8,12 +8,12 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" namespace base { // Query information about the processor. -class BASE_API CPU { +class BASE_EXPORT CPU { public: // Constructor CPU(); diff --git a/base/debug/alias.h b/base/debug/alias.h index fcf3653..4946e558 100644 --- a/base/debug/alias.h +++ b/base/debug/alias.h @@ -6,7 +6,7 @@ #define BASE_DEBUG_ALIAS_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" namespace base { namespace debug { @@ -14,7 +14,7 @@ namespace debug { // Make the optimizer think that var is aliased. This is to prevent it from // optimizing out variables that that would not otherwise be live at the point // of a potential crash. -void BASE_API Alias(const void* var); +void BASE_EXPORT Alias(const void* var); } // namespace debug } // namespace base diff --git a/base/debug/debugger.h b/base/debug/debugger.h index bb937a0..489007b 100644 --- a/base/debug/debugger.h +++ b/base/debug/debugger.h @@ -10,18 +10,18 @@ #define BASE_DEBUG_DEBUGGER_H #pragma once -#include "base/base_api.h" +#include "base/base_export.h" namespace base { namespace debug { // Starts the registered system-wide JIT debugger to attach it to specified // process. -BASE_API bool SpawnDebuggerOnProcess(unsigned process_id); +BASE_EXPORT bool SpawnDebuggerOnProcess(unsigned process_id); // Waits wait_seconds seconds for a debugger to attach to the current process. // When silent is false, an exception is thrown when a debugger is detected. -BASE_API bool WaitForDebugger(int wait_seconds, bool silent); +BASE_EXPORT bool WaitForDebugger(int wait_seconds, bool silent); // Returns true if the given process is being run under a debugger. // @@ -30,18 +30,18 @@ BASE_API bool WaitForDebugger(int wait_seconds, bool silent); // // WARNING: Because of this, on OS X, a call MUST be made to this function // BEFORE the sandbox is enabled. -BASE_API bool BeingDebugged(); +BASE_EXPORT bool BeingDebugged(); // Break into the debugger, assumes a debugger is present. -BASE_API void BreakDebugger(); +BASE_EXPORT void BreakDebugger(); // Used in test code, this controls whether showing dialogs and breaking into // the debugger is suppressed for debug errors, even in debug mode (normally // release mode doesn't do this stuff -- this is controlled separately). // Normally UI is not suppressed. This is normally used when running automated // tests where we want a crash rather than a dialog or a debugger. -BASE_API void SetSuppressDebugUI(bool suppress); -BASE_API bool IsDebugUISuppressed(); +BASE_EXPORT void SetSuppressDebugUI(bool suppress); +BASE_EXPORT bool IsDebugUISuppressed(); } // namespace debug } // namespace base diff --git a/base/debug/profiler.h b/base/debug/profiler.h index 55c0c9f..a8f1297 100644 --- a/base/debug/profiler.h +++ b/base/debug/profiler.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" // The Profiler functions allow usage of the underlying sampling based // profiler. If the application has not been built with the necessary @@ -20,16 +20,16 @@ namespace debug { // Start profiling with the supplied name. // {pid} will be replaced by the process' pid and {count} will be replaced // by the count of the profile run (starts at 1 with each process). -BASE_API void StartProfiling(const std::string& name); +BASE_EXPORT void StartProfiling(const std::string& name); // Stop profiling and write out data. -BASE_API void StopProfiling(); +BASE_EXPORT void StopProfiling(); // Force data to be written to file. -BASE_API void FlushProfiling(); +BASE_EXPORT void FlushProfiling(); // Returns true if process is being profiled. -BASE_API bool BeingProfiled(); +BASE_EXPORT bool BeingProfiled(); } // namespace debug } // namespace base diff --git a/base/debug/stack_trace.h b/base/debug/stack_trace.h index acc7223..02cb01f 100644 --- a/base/debug/stack_trace.h +++ b/base/debug/stack_trace.h @@ -8,7 +8,7 @@ #include <iosfwd> -#include "base/base_api.h" +#include "base/base_export.h" #include "build/build_config.h" #if defined(OS_WIN) @@ -21,7 +21,7 @@ namespace debug { // A stacktrace can be helpful in debugging. For example, you can include a // stacktrace member in a object (probably around #ifndef NDEBUG) so that you // can later see where the given object was created from. -class BASE_API StackTrace { +class BASE_EXPORT StackTrace { public: // Creates a stacktrace from the current location. StackTrace(); diff --git a/base/debug/trace_event.h b/base/debug/trace_event.h index d1c7418..79690f1 100644 --- a/base/debug/trace_event.h +++ b/base/debug/trace_event.h @@ -302,7 +302,7 @@ enum TraceEventPhase { // Simple union of values. This is much lighter weight than base::Value, which // requires dynamic allocation and a vtable. To keep the trace runtime overhead // low, we want constant size storage here. -class BASE_API TraceValue { +class BASE_EXPORT TraceValue { public: enum Type { TRACE_TYPE_UNDEFINED, @@ -442,7 +442,7 @@ class TraceEvent { }; -class BASE_API TraceLog { +class BASE_EXPORT TraceLog { public: static TraceLog* GetInstance(); @@ -527,7 +527,7 @@ class BASE_API TraceLog { namespace internal { // Used by TRACE_EVENTx macro. Do not use directly. -class BASE_API TraceEndOnScopeClose { +class BASE_EXPORT TraceEndOnScopeClose { public: TraceEndOnScopeClose() : p_data_(NULL) {} ~TraceEndOnScopeClose() { @@ -556,7 +556,7 @@ class BASE_API TraceEndOnScopeClose { }; // Used by TRACE_EVENTx macro. Do not use directly. -class BASE_API TraceEndOnScopeCloseThreshold { +class BASE_EXPORT TraceEndOnScopeCloseThreshold { public: TraceEndOnScopeCloseThreshold() : p_data_(NULL) {} ~TraceEndOnScopeCloseThreshold() { diff --git a/base/debug/trace_event_win.h b/base/debug/trace_event_win.h index 6e6bcb4..c82782c 100644 --- a/base/debug/trace_event_win.h +++ b/base/debug/trace_event_win.h @@ -9,7 +9,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/debug/trace_event.h" #include "base/win/event_trace_provider.h" @@ -22,7 +22,7 @@ namespace debug { // This EtwTraceProvider subclass implements ETW logging // for the macros above on Windows. -class BASE_API TraceEventETWProvider : public base::win::EtwTraceProvider { +class BASE_EXPORT TraceEventETWProvider : public base::win::EtwTraceProvider { public: // Start logging trace events. // This is a noop in this implementation. @@ -93,13 +93,13 @@ class BASE_API TraceEventETWProvider : public base::win::EtwTraceProvider { }; // The ETW trace provider GUID. -BASE_API extern const GUID kChromeTraceProviderName; +BASE_EXPORT extern const GUID kChromeTraceProviderName; // The ETW event class GUID for 32 bit events. -BASE_API extern const GUID kTraceEventClass32; +BASE_EXPORT extern const GUID kTraceEventClass32; // The ETW event class GUID for 64 bit events. -BASE_API extern const GUID kTraceEventClass64; +BASE_EXPORT extern const GUID kTraceEventClass64; // The ETW event types, IDs 0x00-0x09 are reserved, so start at 0x10. const base::win::EtwEventType kTraceEventTypeBegin = 0x10; diff --git a/base/environment.h b/base/environment.h index 9d2a662..8a31e07 100644 --- a/base/environment.h +++ b/base/environment.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "build/build_config.h" namespace base { @@ -16,12 +16,12 @@ namespace base { namespace env_vars { #if defined(OS_POSIX) -BASE_API extern const char kHome[]; +BASE_EXPORT extern const char kHome[]; #endif } // namespace env_vars -class BASE_API Environment { +class BASE_EXPORT Environment { public: virtual ~Environment(); diff --git a/base/event_recorder.h b/base/event_recorder.h index 1f7aa61..75a738e 100644 --- a/base/event_recorder.h +++ b/base/event_recorder.h @@ -6,7 +6,7 @@ #define BASE_EVENT_RECORDER_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "build/build_config.h" @@ -33,7 +33,7 @@ namespace base { // Why? Imagine if the product had a "record a macro" feature. // You might be recording globally, while recording or playing back // a macro. I don't think two playbacks make sense. -class BASE_API EventRecorder { +class BASE_EXPORT EventRecorder { public: // Get the singleton EventRecorder. // We can only handle one recorder/player at a time. diff --git a/base/file_descriptor_shuffle.h b/base/file_descriptor_shuffle.h index 0a649fa..335b008 100644 --- a/base/file_descriptor_shuffle.h +++ b/base/file_descriptor_shuffle.h @@ -24,7 +24,7 @@ #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" namespace base { @@ -69,11 +69,12 @@ struct InjectionArc { typedef std::vector<InjectionArc> InjectiveMultimap; -BASE_API bool PerformInjectiveMultimap(const InjectiveMultimap& map, - InjectionDelegate* delegate); +BASE_EXPORT bool PerformInjectiveMultimap(const InjectiveMultimap& map, + InjectionDelegate* delegate); -BASE_API bool PerformInjectiveMultimapDestructive(InjectiveMultimap* map, - InjectionDelegate* delegate); +BASE_EXPORT bool PerformInjectiveMultimapDestructive( + InjectiveMultimap* map, + InjectionDelegate* delegate); // This function will not call malloc but will mutate |map| static inline bool ShuffleFileDescriptors(InjectiveMultimap* map) { diff --git a/base/file_path.h b/base/file_path.h index b8f7861..6396833 100644 --- a/base/file_path.h +++ b/base/file_path.h @@ -104,7 +104,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/compiler_specific.h" #include "base/hash_tables.h" #include "base/string16.h" @@ -124,7 +124,7 @@ class Pickle; // An abstraction to isolate users from the differences between native // pathnames on different platforms. -class BASE_API FilePath { +class BASE_EXPORT FilePath { public: #if defined(OS_POSIX) // On most platforms, native pathnames are char arrays, and the encoding diff --git a/base/file_util.h b/base/file_util.h index 6d786c2..a6bb972 100644 --- a/base/file_util.h +++ b/base/file_util.h @@ -27,7 +27,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/file_path.h" #include "base/memory/scoped_ptr.h" @@ -50,19 +50,19 @@ namespace file_util { // Functions that operate purely on a path string w/o touching the filesystem: // Returns true if the given path ends with a path separator character. -BASE_API bool EndsWithSeparator(const FilePath& path); +BASE_EXPORT bool EndsWithSeparator(const FilePath& path); // Makes sure that |path| ends with a separator IFF path is a directory that // exists. Returns true if |path| is an existing directory, false otherwise. -BASE_API bool EnsureEndsWithSeparator(FilePath* path); +BASE_EXPORT bool EnsureEndsWithSeparator(FilePath* path); // Convert provided relative path into an absolute path. Returns false on // error. On POSIX, this function fails if the path does not exist. -BASE_API bool AbsolutePath(FilePath* path); +BASE_EXPORT bool AbsolutePath(FilePath* path); // Returns true if |parent| contains |child|. Both paths are converted to // absolute paths before doing the comparison. -BASE_API bool ContainsPath(const FilePath& parent, const FilePath& child); +BASE_EXPORT bool ContainsPath(const FilePath& parent, const FilePath& child); //----------------------------------------------------------------------------- // Functions that involve filesystem access or modification: @@ -75,15 +75,15 @@ BASE_API bool ContainsPath(const FilePath& parent, const FilePath& child); // timestmap of file creation time. If you need to avoid such // mis-detection perfectly, you should wait one second before // obtaining |file_time|. -BASE_API int CountFilesCreatedAfter(const FilePath& path, - const base::Time& file_time); +BASE_EXPORT int CountFilesCreatedAfter(const FilePath& path, + const base::Time& file_time); // Returns the total number of bytes used by all the files under |root_path|. // If the path does not exist the function returns 0. // // This function is implemented using the FileEnumerator class so it is not // particularly speedy in any platform. -BASE_API int64 ComputeDirectorySize(const FilePath& root_path); +BASE_EXPORT int64 ComputeDirectorySize(const FilePath& root_path); // Returns the total number of bytes used by all files matching the provided // |pattern|, on this |directory| (without recursion). If the path does not @@ -91,8 +91,8 @@ BASE_API int64 ComputeDirectorySize(const FilePath& root_path); // // This function is implemented using the FileEnumerator class so it is not // particularly speedy in any platform. -BASE_API int64 ComputeFilesSize(const FilePath& directory, - const FilePath::StringType& pattern); +BASE_EXPORT int64 ComputeFilesSize(const FilePath& directory, + const FilePath::StringType& pattern); // Deletes the given path, whether it's a file or a directory. // If it's a directory, it's perfectly happy to delete all of the @@ -102,7 +102,7 @@ BASE_API int64 ComputeFilesSize(const FilePath& directory, // // WARNING: USING THIS WITH recursive==true IS EQUIVALENT // TO "rm -rf", SO USE WITH CAUTION. -BASE_API bool Delete(const FilePath& path, bool recursive); +BASE_EXPORT bool Delete(const FilePath& path, bool recursive); #if defined(OS_WIN) // Schedules to delete the given path, whether it's a file or a directory, until @@ -110,24 +110,25 @@ BASE_API bool Delete(const FilePath& path, bool recursive); // Note: // 1) The file/directory to be deleted should exist in a temp folder. // 2) The directory to be deleted must be empty. -BASE_API bool DeleteAfterReboot(const FilePath& path); +BASE_EXPORT bool DeleteAfterReboot(const FilePath& path); #endif // Moves the given path, whether it's a file or a directory. // If a simple rename is not possible, such as in the case where the paths are // on different volumes, this will attempt to copy and delete. Returns // true for success. -BASE_API bool Move(const FilePath& from_path, const FilePath& to_path); +BASE_EXPORT bool Move(const FilePath& from_path, const FilePath& to_path); // Renames file |from_path| to |to_path|. Both paths must be on the same // volume, or the function will fail. Destination file will be created // if it doesn't exist. Prefer this function over Move when dealing with // temporary files. On Windows it preserves attributes of the target file. // Returns true on success. -BASE_API bool ReplaceFile(const FilePath& from_path, const FilePath& to_path); +BASE_EXPORT bool ReplaceFile(const FilePath& from_path, + const FilePath& to_path); // Copies a single file. Use CopyDirectory to copy directories. -BASE_API bool CopyFile(const FilePath& from_path, const FilePath& to_path); +BASE_EXPORT bool CopyFile(const FilePath& from_path, const FilePath& to_path); // Copies the given path, and optionally all subdirectories and their contents // as well. @@ -136,61 +137,62 @@ BASE_API bool CopyFile(const FilePath& from_path, const FilePath& to_path); // Don't use wildcards on the names, it may stop working without notice. // // If you only need to copy a file use CopyFile, it's faster. -BASE_API bool CopyDirectory(const FilePath& from_path, const FilePath& to_path, - bool recursive); +BASE_EXPORT bool CopyDirectory(const FilePath& from_path, + const FilePath& to_path, + bool recursive); // Returns true if the given path exists on the local filesystem, // false otherwise. -BASE_API bool PathExists(const FilePath& path); +BASE_EXPORT bool PathExists(const FilePath& path); // Returns true if the given path is writable by the user, false otherwise. -BASE_API bool PathIsWritable(const FilePath& path); +BASE_EXPORT bool PathIsWritable(const FilePath& path); // Returns true if the given path exists and is a directory, false otherwise. -BASE_API bool DirectoryExists(const FilePath& path); +BASE_EXPORT bool DirectoryExists(const FilePath& path); #if defined(OS_WIN) // Gets the creation time of the given file (expressed in the local timezone), // and returns it via the creation_time parameter. Returns true if successful, // false otherwise. -BASE_API bool GetFileCreationLocalTime(const std::wstring& filename, - LPSYSTEMTIME creation_time); +BASE_EXPORT bool GetFileCreationLocalTime(const std::wstring& filename, + LPSYSTEMTIME creation_time); // Same as above, but takes a previously-opened file handle instead of a name. -BASE_API bool GetFileCreationLocalTimeFromHandle(HANDLE file_handle, - LPSYSTEMTIME creation_time); +BASE_EXPORT bool GetFileCreationLocalTimeFromHandle(HANDLE file_handle, + LPSYSTEMTIME creation_time); #endif // defined(OS_WIN) // Returns true if the contents of the two files given are equal, false // otherwise. If either file can't be read, returns false. -BASE_API bool ContentsEqual(const FilePath& filename1, - const FilePath& filename2); +BASE_EXPORT bool ContentsEqual(const FilePath& filename1, + const FilePath& filename2); // Returns true if the contents of the two text files given are equal, false // otherwise. This routine treats "\r\n" and "\n" as equivalent. -BASE_API bool TextContentsEqual(const FilePath& filename1, - const FilePath& filename2); +BASE_EXPORT bool TextContentsEqual(const FilePath& filename1, + const FilePath& filename2); // Read the file at |path| into |contents|, returning true on success. // |contents| may be NULL, in which case this function is useful for its // side effect of priming the disk cache. // Useful for unit tests. -BASE_API bool ReadFileToString(const FilePath& path, std::string* contents); +BASE_EXPORT bool ReadFileToString(const FilePath& path, std::string* contents); #if defined(OS_POSIX) // Read exactly |bytes| bytes from file descriptor |fd|, storing the result // in |buffer|. This function is protected against EINTR and partial reads. // Returns true iff |bytes| bytes have been successfuly read from |fd|. -BASE_API bool ReadFromFD(int fd, char* buffer, size_t bytes); +BASE_EXPORT bool ReadFromFD(int fd, char* buffer, size_t bytes); // Creates a symbolic link at |symlink| pointing to |target|. Returns // false on failure. -BASE_API bool CreateSymbolicLink(const FilePath& target, - const FilePath& symlink); +BASE_EXPORT bool CreateSymbolicLink(const FilePath& target, + const FilePath& symlink); // Reads the given |symlink| and returns where it points to in |target|. // Returns false upon failure. -BASE_API bool ReadSymbolicLink(const FilePath& symlink, FilePath* target); +BASE_EXPORT bool ReadSymbolicLink(const FilePath& symlink, FilePath* target); #endif // defined(OS_POSIX) #if defined(OS_WIN) @@ -198,7 +200,7 @@ BASE_API bool ReadSymbolicLink(const FilePath& symlink, FilePath* target); // This methods tries to resolve a shortcut .LNK file. If the |path| is valid // returns true and puts the target into the |path|, otherwise returns // false leaving the path as it is. -BASE_API bool ResolveShortcut(FilePath* path); +BASE_EXPORT bool ResolveShortcut(FilePath* path); // Create a Windows shortcut (.LNK file) // This method creates a shortcut link using the information given. Ensure @@ -209,14 +211,14 @@ BASE_API bool ResolveShortcut(FilePath* path); // The 'icon' can specify a dll or exe in which case the icon index is the // resource id. 'app_id' is the app model id for the shortcut on Win7. // Note that if the shortcut exists it will overwrite it. -BASE_API bool CreateShortcutLink(const wchar_t *source, - const wchar_t *destination, - const wchar_t *working_dir, - const wchar_t *arguments, - const wchar_t *description, - const wchar_t *icon, - int icon_index, - const wchar_t* app_id); +BASE_EXPORT bool CreateShortcutLink(const wchar_t *source, + const wchar_t *destination, + const wchar_t *working_dir, + const wchar_t *arguments, + const wchar_t *description, + const wchar_t *icon, + int icon_index, + const wchar_t* app_id); // Update a Windows shortcut (.LNK file). This method assumes the shortcut // link already exists (otherwise false is returned). Ensure you have @@ -225,92 +227,92 @@ BASE_API bool CreateShortcutLink(const wchar_t *source, // is NULL no changes are made to the shortcut). 'destination' is the link // file to be updated. 'app_id' is the app model id for the shortcut on Win7. // For best results pass the filename with the .lnk extension. -BASE_API bool UpdateShortcutLink(const wchar_t *source, - const wchar_t *destination, - const wchar_t *working_dir, - const wchar_t *arguments, - const wchar_t *description, - const wchar_t *icon, - int icon_index, - const wchar_t* app_id); +BASE_EXPORT bool UpdateShortcutLink(const wchar_t *source, + const wchar_t *destination, + const wchar_t *working_dir, + const wchar_t *arguments, + const wchar_t *description, + const wchar_t *icon, + int icon_index, + const wchar_t* app_id); // Pins a shortcut to the Windows 7 taskbar. The shortcut file must already // exist and be a shortcut that points to an executable. -BASE_API bool TaskbarPinShortcutLink(const wchar_t* shortcut); +BASE_EXPORT bool TaskbarPinShortcutLink(const wchar_t* shortcut); // Unpins a shortcut from the Windows 7 taskbar. The shortcut must exist and // already be pinned to the taskbar. -BASE_API bool TaskbarUnpinShortcutLink(const wchar_t* shortcut); +BASE_EXPORT bool TaskbarUnpinShortcutLink(const wchar_t* shortcut); // Copy from_path to to_path recursively and then delete from_path recursively. // Returns true if all operations succeed. // This function simulates Move(), but unlike Move() it works across volumes. // This fuction is not transactional. -BASE_API bool CopyAndDeleteDirectory(const FilePath& from_path, - const FilePath& to_path); +BASE_EXPORT bool CopyAndDeleteDirectory(const FilePath& from_path, + const FilePath& to_path); #endif // defined(OS_WIN) // Return true if the given directory is empty -BASE_API bool IsDirectoryEmpty(const FilePath& dir_path); +BASE_EXPORT bool IsDirectoryEmpty(const FilePath& dir_path); // Get the temporary directory provided by the system. // WARNING: DON'T USE THIS. If you want to create a temporary file, use one of // the functions below. -BASE_API bool GetTempDir(FilePath* path); +BASE_EXPORT bool GetTempDir(FilePath* path); // Get a temporary directory for shared memory files. // Only useful on POSIX; redirects to GetTempDir() on Windows. -BASE_API bool GetShmemTempDir(FilePath* path); +BASE_EXPORT bool GetShmemTempDir(FilePath* path); // Get the home directory. This is more complicated than just getenv("HOME") // as it knows to fall back on getpwent() etc. -BASE_API FilePath GetHomeDir(); +BASE_EXPORT FilePath GetHomeDir(); // Creates a temporary file. The full path is placed in |path|, and the // function returns true if was successful in creating the file. The file will // be empty and all handles closed after this function returns. -BASE_API bool CreateTemporaryFile(FilePath* path); +BASE_EXPORT bool CreateTemporaryFile(FilePath* path); // Same as CreateTemporaryFile but the file is created in |dir|. -BASE_API bool CreateTemporaryFileInDir(const FilePath& dir, - FilePath* temp_file); +BASE_EXPORT bool CreateTemporaryFileInDir(const FilePath& dir, + FilePath* temp_file); // Create and open a temporary file. File is opened for read/write. // The full path is placed in |path|. // Returns a handle to the opened file or NULL if an error occured. -BASE_API FILE* CreateAndOpenTemporaryFile(FilePath* path); +BASE_EXPORT FILE* CreateAndOpenTemporaryFile(FilePath* path); // Like above but for shmem files. Only useful for POSIX. -BASE_API FILE* CreateAndOpenTemporaryShmemFile(FilePath* path); +BASE_EXPORT FILE* CreateAndOpenTemporaryShmemFile(FilePath* path); // Similar to CreateAndOpenTemporaryFile, but the file is created in |dir|. -BASE_API FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir, - FilePath* path); +BASE_EXPORT FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir, + FilePath* path); // Create a new directory. If prefix is provided, the new directory name is in // the format of prefixyyyy. // NOTE: prefix is ignored in the POSIX implementation. // If success, return true and output the full path of the directory created. -BASE_API bool CreateNewTempDirectory(const FilePath::StringType& prefix, - FilePath* new_temp_path); +BASE_EXPORT bool CreateNewTempDirectory(const FilePath::StringType& prefix, + FilePath* new_temp_path); // Create a directory within another directory. // Extra characters will be appended to |prefix| to ensure that the // new directory does not have the same name as an existing directory. -BASE_API bool CreateTemporaryDirInDir(const FilePath& base_dir, - const FilePath::StringType& prefix, - FilePath* new_dir); +BASE_EXPORT bool CreateTemporaryDirInDir(const FilePath& base_dir, + const FilePath::StringType& prefix, + FilePath* new_dir); // Creates a directory, as well as creating any parent directories, if they // don't exist. Returns 'true' on successful creation, or if the directory // already exists. The directory is only readable by the current user. -BASE_API bool CreateDirectory(const FilePath& full_path); +BASE_EXPORT bool CreateDirectory(const FilePath& full_path); // Returns the file size. Returns true on success. -BASE_API bool GetFileSize(const FilePath& file_path, int64* file_size); +BASE_EXPORT bool GetFileSize(const FilePath& file_path, int64* file_size); // Returns true if the given path's base name is ".". -BASE_API bool IsDot(const FilePath& path); +BASE_EXPORT bool IsDot(const FilePath& path); // Returns true if the given path's base name is "..". -BASE_API bool IsDotDot(const FilePath& path); +BASE_EXPORT bool IsDotDot(const FilePath& path); // Sets |real_path| to |path| with symbolic links and junctions expanded. // On windows, make sure the path starts with a lettered drive. @@ -318,65 +320,65 @@ BASE_API bool IsDotDot(const FilePath& path); // a directory or to a nonexistent path. On windows, this function will // fail if |path| is a junction or symlink that points to an empty file, // or if |real_path| would be longer than MAX_PATH characters. -BASE_API bool NormalizeFilePath(const FilePath& path, FilePath* real_path); +BASE_EXPORT bool NormalizeFilePath(const FilePath& path, FilePath* real_path); #if defined(OS_WIN) // Given an existing file in |path|, it returns in |real_path| the path // in the native NT format, of the form "\Device\HarddiskVolumeXX\..". // Returns false it it fails. Empty files cannot be resolved with this // function. -BASE_API bool NormalizeToNativeFilePath(const FilePath& path, - FilePath* nt_path); +BASE_EXPORT bool NormalizeToNativeFilePath(const FilePath& path, + FilePath* nt_path); #endif // This function will return if the given file is a symlink or not. -BASE_API bool IsLink(const FilePath& file_path); +BASE_EXPORT bool IsLink(const FilePath& file_path); // Returns information about the given file path. -BASE_API bool GetFileInfo(const FilePath& file_path, - base::PlatformFileInfo* info); +BASE_EXPORT bool GetFileInfo(const FilePath& file_path, + base::PlatformFileInfo* info); // Sets the time of the last access and the time of the last modification. -BASE_API bool TouchFile(const FilePath& path, - const base::Time& last_accessed, - const base::Time& last_modified); +BASE_EXPORT bool TouchFile(const FilePath& path, + const base::Time& last_accessed, + const base::Time& last_modified); // Set the time of the last modification. Useful for unit tests. -BASE_API bool SetLastModifiedTime(const FilePath& path, - const base::Time& last_modified); +BASE_EXPORT bool SetLastModifiedTime(const FilePath& path, + const base::Time& last_modified); #if defined(OS_POSIX) // Store inode number of |path| in |inode|. Return true on success. -BASE_API bool GetInode(const FilePath& path, ino_t* inode); +BASE_EXPORT bool GetInode(const FilePath& path, ino_t* inode); #endif // Wrapper for fopen-like calls. Returns non-NULL FILE* on success. -BASE_API FILE* OpenFile(const FilePath& filename, const char* mode); +BASE_EXPORT FILE* OpenFile(const FilePath& filename, const char* mode); // Closes file opened by OpenFile. Returns true on success. -BASE_API bool CloseFile(FILE* file); +BASE_EXPORT bool CloseFile(FILE* file); // Truncates an open file to end at the location of the current file pointer. // This is a cross-platform analog to Windows' SetEndOfFile() function. -BASE_API bool TruncateFile(FILE* file); +BASE_EXPORT bool TruncateFile(FILE* file); // Reads the given number of bytes from the file into the buffer. Returns // the number of read bytes, or -1 on error. -BASE_API int ReadFile(const FilePath& filename, char* data, int size); +BASE_EXPORT int ReadFile(const FilePath& filename, char* data, int size); // Writes the given buffer into the file, overwriting any data that was // previously there. Returns the number of bytes written, or -1 on error. -BASE_API int WriteFile(const FilePath& filename, const char* data, int size); +BASE_EXPORT int WriteFile(const FilePath& filename, const char* data, int size); #if defined(OS_POSIX) // Append the data to |fd|. Does not close |fd| when done. -BASE_API int WriteFileDescriptor(const int fd, const char* data, int size); +BASE_EXPORT int WriteFileDescriptor(const int fd, const char* data, int size); #endif // Gets the current working directory for the process. -BASE_API bool GetCurrentDirectory(FilePath* path); +BASE_EXPORT bool GetCurrentDirectory(FilePath* path); // Sets the current working directory for the process. -BASE_API bool SetCurrentDirectory(const FilePath& path); +BASE_EXPORT bool SetCurrentDirectory(const FilePath& path); // A class to handle auto-closing of FILE*'s. class ScopedFILEClose { @@ -410,7 +412,7 @@ typedef scoped_ptr_malloc<int, ScopedFDClose> ScopedFD; // // DO NOT USE FROM THE MAIN THREAD of your application unless it is a test // program where latency does not matter. This class is blocking. -class BASE_API FileEnumerator { +class BASE_EXPORT FileEnumerator { public: #if defined(OS_WIN) typedef WIN32_FIND_DATA FindInfo; @@ -511,7 +513,7 @@ class BASE_API FileEnumerator { DISALLOW_COPY_AND_ASSIGN(FileEnumerator); }; -class BASE_API MemoryMappedFile { +class BASE_EXPORT MemoryMappedFile { public: // The default constructor sets all members to invalid/null values. MemoryMappedFile(); @@ -566,12 +568,12 @@ class BASE_API MemoryMappedFile { // Renames a file using the SHFileOperation API to ensure that the target file // gets the correct default security descriptor in the new path. -BASE_API bool RenameFileAndResetSecurityDescriptor( +BASE_EXPORT bool RenameFileAndResetSecurityDescriptor( const FilePath& source_file_path, const FilePath& target_file_path); // Returns whether the file has been modified since a particular date. -BASE_API bool HasFileBeenModifiedSince( +BASE_EXPORT bool HasFileBeenModifiedSince( const FileEnumerator::FindInfo& find_info, const base::Time& cutoff_time); @@ -633,8 +635,8 @@ inline bool MakeFileUnreadable(const FilePath& path) { // is passed in. If it is 0 then the whole file is paged in. The step size // which indicates the number of bytes to skip after every page touched is // also passed in. -bool BASE_API PreReadImage(const wchar_t* file_path, size_t size_to_read, - size_t step_size); +bool BASE_EXPORT PreReadImage(const wchar_t* file_path, size_t size_to_read, + size_t step_size); #endif // OS_WIN #if defined(OS_LINUX) @@ -654,7 +656,7 @@ enum FileSystemType { // Attempts determine the FileSystemType for |path|. // Returns false if |path| doesn't exist. -BASE_API bool GetFileSystemType(const FilePath& path, FileSystemType* type); +BASE_EXPORT bool GetFileSystemType(const FilePath& path, FileSystemType* type); #endif } // namespace file_util diff --git a/base/file_util_deprecated.h b/base/file_util_deprecated.h index 675ee61..e0ebbe0 100644 --- a/base/file_util_deprecated.h +++ b/base/file_util_deprecated.h @@ -14,7 +14,7 @@ #define BASE_FILE_UTIL_DEPRECATED_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "build/build_config.h" // We've successfully deprecated all of these functions on non-Windows @@ -25,23 +25,24 @@ namespace file_util { // Use the FilePath versions instead. -BASE_API FILE* OpenFile(const std::string& filename, const char* mode); -BASE_API FILE* OpenFile(const std::wstring& filename, const char* mode); +BASE_EXPORT FILE* OpenFile(const std::string& filename, const char* mode); +BASE_EXPORT FILE* OpenFile(const std::wstring& filename, const char* mode); // Appends new_ending to path, adding a separator between the two if necessary. -BASE_API void AppendToPath(std::wstring* path, const std::wstring& new_ending); +BASE_EXPORT void AppendToPath(std::wstring* path, + const std::wstring& new_ending); // Use FilePath::Extension instead. -BASE_API std::wstring GetFileExtensionFromPath(const std::wstring& path); +BASE_EXPORT std::wstring GetFileExtensionFromPath(const std::wstring& path); // Use version that takes a FilePath. -BASE_API bool Delete(const std::wstring& path, bool recursive); -BASE_API bool CopyDirectory(const std::wstring& from_path, - const std::wstring& to_path, - bool recursive); -BASE_API int ReadFile(const std::wstring& filename, char* data, int size); -BASE_API int WriteFile(const std::wstring& filename, - const char* data, int size); +BASE_EXPORT bool Delete(const std::wstring& path, bool recursive); +BASE_EXPORT bool CopyDirectory(const std::wstring& from_path, + const std::wstring& to_path, + bool recursive); +BASE_EXPORT int ReadFile(const std::wstring& filename, char* data, int size); +BASE_EXPORT int WriteFile(const std::wstring& filename, + const char* data, int size); } diff --git a/base/file_util_proxy.h b/base/file_util_proxy.h index 42b9cca..928004a 100644 --- a/base/file_util_proxy.h +++ b/base/file_util_proxy.h @@ -7,7 +7,7 @@ #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/callback_old.h" #include "base/file_path.h" #include "base/file_util.h" @@ -21,7 +21,7 @@ class MessageLoopProxy; class Time; // This class provides asynchronous access to common file routines. -class BASE_API FileUtilProxy { +class BASE_EXPORT FileUtilProxy { public: // Holds metadata for file or directory entry. Used by ReadDirectoryCallback. struct Entry { diff --git a/base/file_version_info.h b/base/file_version_info.h index ab9ebe1..b41dc63 100644 --- a/base/file_version_info.h +++ b/base/file_version_info.h @@ -16,7 +16,7 @@ extern "C" IMAGE_DOS_HEADER __ImageBase; #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string16.h" class FilePath; @@ -38,14 +38,14 @@ class FileVersionInfo { // Creates a FileVersionInfo for the specified path. Returns NULL if something // goes wrong (typically the file does not exit or cannot be opened). The // returned object should be deleted when you are done with it. - BASE_API static FileVersionInfo* CreateFileVersionInfo( + BASE_EXPORT static FileVersionInfo* CreateFileVersionInfo( const FilePath& file_path); #endif // OS_WIN || OS_MACOSX #if defined(OS_WIN) // Creates a FileVersionInfo for the specified module. Returns NULL in case // of error. The returned object should be deleted when you are done with it. - BASE_API static FileVersionInfo* CreateFileVersionInfoForModule( + BASE_EXPORT static FileVersionInfo* CreateFileVersionInfoForModule( HMODULE module); // Creates a FileVersionInfo for the current module. Returns NULL in case @@ -60,7 +60,7 @@ class FileVersionInfo { #else // Creates a FileVersionInfo for the current module. Returns NULL in case // of error. The returned object should be deleted when you are done with it. - BASE_API static FileVersionInfo* CreateFileVersionInfoForCurrentModule(); + BASE_EXPORT static FileVersionInfo* CreateFileVersionInfoForCurrentModule(); #endif // OS_WIN // Accessors to the different version properties. diff --git a/base/file_version_info_win.h b/base/file_version_info_win.h index 89ac67e..6a488b4 100644 --- a/base/file_version_info_win.h +++ b/base/file_version_info_win.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/file_version_info.h" #include "base/memory/scoped_ptr.h" @@ -18,8 +18,8 @@ typedef tagVS_FIXEDFILEINFO VS_FIXEDFILEINFO; class FileVersionInfoWin : public FileVersionInfo { public: - BASE_API FileVersionInfoWin(void* data, int language, int code_page); - BASE_API ~FileVersionInfoWin(); + BASE_EXPORT FileVersionInfoWin(void* data, int language, int code_page); + BASE_EXPORT ~FileVersionInfoWin(); // Accessors to the different version properties. // Returns an empty string if the property is not found. @@ -41,11 +41,11 @@ class FileVersionInfoWin : public FileVersionInfo { virtual bool is_official_build(); // Lets you access other properties not covered above. - BASE_API bool GetValue(const wchar_t* name, std::wstring* value); + BASE_EXPORT bool GetValue(const wchar_t* name, std::wstring* value); // Similar to GetValue but returns a wstring (empty string if the property // does not exist). - BASE_API std::wstring GetStringValue(const wchar_t* name); + BASE_EXPORT std::wstring GetStringValue(const wchar_t* name); // Get the fixed file info if it exists. Otherwise NULL VS_FIXEDFILEINFO* fixed_file_info() { return fixed_file_info_; } diff --git a/base/files/file_path_watcher.h b/base/files/file_path_watcher.h index ec41f53..580ec99 100644 --- a/base/files/file_path_watcher.h +++ b/base/files/file_path_watcher.h @@ -8,7 +8,7 @@ #define BASE_FILES_FILE_PATH_WATCHER_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/file_path.h" #include "base/memory/ref_counted.h" @@ -26,7 +26,7 @@ namespace files { // detect the creation and deletion of files in a watched directory, but will // not detect modifications to those files. See file_path_watcher_mac.cc for // details. -class BASE_API FilePathWatcher { +class BASE_EXPORT FilePathWatcher { public: // Declares the callback client code implements to receive notifications. Note // that implementations of this interface should not keep a reference to the diff --git a/base/global_descriptors_posix.h b/base/global_descriptors_posix.h index d4650e5..452afa7 100644 --- a/base/global_descriptors_posix.h +++ b/base/global_descriptors_posix.h @@ -34,7 +34,7 @@ namespace base { // It maps from an abstract key to a descriptor. If independent modules each // need to define keys, then values should be chosen randomly so as not to // collide. -class BASE_API GlobalDescriptors { +class BASE_EXPORT GlobalDescriptors { public: typedef uint32_t Key; typedef std::vector<std::pair<Key, int> > Mapping; diff --git a/base/json/json_reader.h b/base/json/json_reader.h index 46e450c..f6ad9da 100644 --- a/base/json/json_reader.h +++ b/base/json/json_reader.h @@ -34,7 +34,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" // Chromium and Chromium OS check out gtest to different places, so we're @@ -47,7 +47,7 @@ namespace base { class Value; -class BASE_API JSONReader { +class BASE_EXPORT JSONReader { public: // A struct to hold a JS token. class Token { diff --git a/base/json/json_writer.h b/base/json/json_writer.h index 36331bb..1eeecb9 100644 --- a/base/json/json_writer.h +++ b/base/json/json_writer.h @@ -8,14 +8,14 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { class Value; -class BASE_API JSONWriter { +class BASE_EXPORT JSONWriter { public: // Given a root node, generates a JSON string and puts it into |json|. // If |pretty_print| is true, return a slightly nicer formated json string diff --git a/base/json/string_escape.h b/base/json/string_escape.h index e12e0bb..1c79ab5 100644 --- a/base/json/string_escape.h +++ b/base/json/string_escape.h @@ -10,7 +10,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string16.h" namespace base { @@ -20,19 +20,19 @@ namespace base { // If |put_in_quotes| is true, the result will be surrounded in double quotes. // The outputted literal, when interpreted by the browser, should result in a // javascript string that is identical and the same length as the input |str|. -BASE_API void JsonDoubleQuote(const std::string& str, - bool put_in_quotes, - std::string* dst); +BASE_EXPORT void JsonDoubleQuote(const std::string& str, + bool put_in_quotes, + std::string* dst); // Same as above, but always returns the result double quoted. -BASE_API std::string GetDoubleQuotedJson(const std::string& str); +BASE_EXPORT std::string GetDoubleQuotedJson(const std::string& str); -BASE_API void JsonDoubleQuote(const string16& str, - bool put_in_quotes, - std::string* dst); +BASE_EXPORT void JsonDoubleQuote(const string16& str, + bool put_in_quotes, + std::string* dst); // Same as above, but always returns the result double quoted. -BASE_API std::string GetDoubleQuotedJson(const string16& str); +BASE_EXPORT std::string GetDoubleQuotedJson(const string16& str); } // namespace base diff --git a/base/lazy_instance.h b/base/lazy_instance.h index 49c7b8c..c6785f3 100644 --- a/base/lazy_instance.h +++ b/base/lazy_instance.h @@ -39,7 +39,7 @@ #include <new> // For placement new. #include "base/atomicops.h" -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/third_party/dynamic_annotations/dynamic_annotations.h" #include "base/threading/thread_restrictions.h" @@ -81,7 +81,7 @@ void (*LeakyLazyInstanceTraits<Type>::Delete)(void* instance) = NULL; // We pull out some of the functionality into a non-templated base, so that we // can implement the more complicated pieces out of line in the .cc file. -class BASE_API LazyInstanceHelper { +class BASE_EXPORT LazyInstanceHelper { protected: enum { STATE_EMPTY = 0, diff --git a/base/linux_util.h b/base/linux_util.h index d33cb88..4f2808b 100644 --- a/base/linux_util.h +++ b/base/linux_util.h @@ -11,7 +11,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" namespace base { @@ -19,29 +19,29 @@ static const char kFindInodeSwitch[] = "--find-inode"; // This is declared here so the crash reporter can access the memory directly // in compromised context without going through the standard library. -BASE_API extern char g_linux_distro[]; +BASE_EXPORT extern char g_linux_distro[]; // Get the Linux Distro if we can, or return "Unknown". -BASE_API std::string GetLinuxDistro(); +BASE_EXPORT std::string GetLinuxDistro(); // Set the Linux Distro string. -BASE_API void SetLinuxDistro(const std::string& distro); +BASE_EXPORT void SetLinuxDistro(const std::string& distro); // Return the inode number for the UNIX domain socket |fd|. -BASE_API bool FileDescriptorGetInode(ino_t* inode_out, int fd); +BASE_EXPORT bool FileDescriptorGetInode(ino_t* inode_out, int fd); // Find the process which holds the given socket, named by inode number. If // multiple processes hold the socket, this function returns false. -BASE_API bool FindProcessHoldingSocket(pid_t* pid_out, ino_t socket_inode); +BASE_EXPORT bool FindProcessHoldingSocket(pid_t* pid_out, ino_t socket_inode); // For a given process |pid|, look through all its threads and find the first // thread with /proc/[pid]/task/[thread_id]/syscall whose first N bytes matches // |expected_data|, where N is the length of |expected_data|. // Returns the thread id or -1 on error. If |syscall_supported| is // set to false the kernel does not support syscall in procfs. -BASE_API pid_t FindThreadIDWithSyscall(pid_t pid, - const std::string& expected_data, - bool* syscall_supported); +BASE_EXPORT pid_t FindThreadIDWithSyscall(pid_t pid, + const std::string& expected_data, + bool* syscall_supported); } // namespace base diff --git a/base/logging.h b/base/logging.h index 0a3a6a3..c18fada 100644 --- a/base/logging.h +++ b/base/logging.h @@ -11,7 +11,7 @@ #include <cstring> #include <sstream> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "build/build_config.h" @@ -193,11 +193,11 @@ typedef char PathChar; // Implementation of the InitLogging() method declared below. We use a // more-specific name so we can #define it above without affecting other code // that has named stuff "InitLogging". -BASE_API bool BaseInitLoggingImpl(const PathChar* log_file, - LoggingDestination logging_dest, - LogLockingState lock_log, - OldFileDeletionState delete_old, - DcheckState dcheck_state); +BASE_EXPORT bool BaseInitLoggingImpl(const PathChar* log_file, + LoggingDestination logging_dest, + LogLockingState lock_log, + OldFileDeletionState delete_old, + DcheckState dcheck_state); // Sets the log file name and other global logging state. Calling this function // is recommended, and is normally done at the beginning of application init. @@ -224,19 +224,19 @@ inline bool InitLogging(const PathChar* log_file, // up to level INFO) if this function is not called. // Note that log messages for VLOG(x) are logged at level -x, so setting // the min log level to negative values enables verbose logging. -BASE_API void SetMinLogLevel(int level); +BASE_EXPORT void SetMinLogLevel(int level); // Gets the current log level. -BASE_API int GetMinLogLevel(); +BASE_EXPORT int GetMinLogLevel(); // Gets the VLOG default verbosity level. -BASE_API int GetVlogVerbosity(); +BASE_EXPORT int GetVlogVerbosity(); // Gets the current vlog level for the given file (usually taken from // __FILE__). // Note that |N| is the size *with* the null terminator. -BASE_API int GetVlogLevelHelper(const char* file_start, size_t N); +BASE_EXPORT int GetVlogLevelHelper(const char* file_start, size_t N); template <size_t N> int GetVlogLevel(const char (&file)[N]) { @@ -247,27 +247,27 @@ int GetVlogLevel(const char (&file)[N]) { // process and thread IDs default to off, the timestamp defaults to on. // If this function is not called, logging defaults to writing the timestamp // only. -BASE_API void SetLogItems(bool enable_process_id, bool enable_thread_id, - bool enable_timestamp, bool enable_tickcount); +BASE_EXPORT void SetLogItems(bool enable_process_id, bool enable_thread_id, + bool enable_timestamp, bool enable_tickcount); // Sets whether or not you'd like to see fatal debug messages popped up in // a dialog box or not. // Dialogs are not shown by default. -BASE_API void SetShowErrorDialogs(bool enable_dialogs); +BASE_EXPORT void SetShowErrorDialogs(bool enable_dialogs); // Sets the Log Assert Handler that will be used to notify of check failures. // The default handler shows a dialog box and then terminate the process, // however clients can use this function to override with their own handling // (e.g. a silent one for Unit Tests) typedef void (*LogAssertHandlerFunction)(const std::string& str); -BASE_API void SetLogAssertHandler(LogAssertHandlerFunction handler); +BASE_EXPORT void SetLogAssertHandler(LogAssertHandlerFunction handler); // Sets the Log Report Handler that will be used to notify of check failures // in non-debug mode. The default handler shows a dialog box and continues // the execution, however clients can use this function to override with their // own handling. typedef void (*LogReportHandlerFunction)(const std::string& str); -BASE_API void SetLogReportHandler(LogReportHandlerFunction handler); +BASE_EXPORT void SetLogReportHandler(LogReportHandlerFunction handler); // Sets the Log Message Handler that gets passed every log message before // it's sent to other log destinations (if any). @@ -275,8 +275,8 @@ BASE_API void SetLogReportHandler(LogReportHandlerFunction handler); // should not be sent to other log destinations. typedef bool (*LogMessageHandlerFunction)(int severity, const char* file, int line, size_t message_start, const std::string& str); -BASE_API void SetLogMessageHandler(LogMessageHandlerFunction handler); -BASE_API LogMessageHandlerFunction GetLogMessageHandler(); +BASE_EXPORT void SetLogMessageHandler(LogMessageHandlerFunction handler); +BASE_EXPORT LogMessageHandlerFunction GetLogMessageHandler(); typedef int LogSeverity; const LogSeverity LOG_VERBOSE = -1; // This is level 1 verbosity @@ -623,7 +623,7 @@ enum { DEBUG_MODE = ENABLE_DLOG }; COMPACT_GOOGLE_LOG_EX_ERROR_REPORT(ClassName , ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_ERROR_REPORT const LogSeverity LOG_DCHECK = LOG_ERROR_REPORT; -BASE_API extern DcheckState g_dcheck_state; +BASE_EXPORT extern DcheckState g_dcheck_state; #define DCHECK_IS_ON() \ ((::logging::g_dcheck_state == \ ::logging::ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS) && \ @@ -722,7 +722,7 @@ const LogSeverity LOG_DCHECK = LOG_INFO; // You shouldn't actually use LogMessage's constructor to log things, // though. You should use the LOG() macro (and variants thereof) // above. -class BASE_API LogMessage { +class BASE_EXPORT LogMessage { public: LogMessage(const char* file, int line, LogSeverity severity, int ctr); @@ -816,11 +816,11 @@ typedef int SystemErrorCode; // Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to // pull in windows.h just for GetLastError() and DWORD. -BASE_API SystemErrorCode GetLastSystemErrorCode(); +BASE_EXPORT SystemErrorCode GetLastSystemErrorCode(); #if defined(OS_WIN) // Appends a formatted system message of the GetLastError() type. -class BASE_API Win32ErrorLogMessage { +class BASE_EXPORT Win32ErrorLogMessage { public: Win32ErrorLogMessage(const char* file, int line, @@ -848,7 +848,7 @@ class BASE_API Win32ErrorLogMessage { }; #elif defined(OS_POSIX) // Appends a formatted system message of the errno type -class BASE_API ErrnoLogMessage { +class BASE_EXPORT ErrnoLogMessage { public: ErrnoLogMessage(const char* file, int line, @@ -872,10 +872,10 @@ class BASE_API ErrnoLogMessage { // NOTE: Since the log file is opened as necessary by the action of logging // statements, there's no guarantee that it will stay closed // after this call. -BASE_API void CloseLogFile(); +BASE_EXPORT void CloseLogFile(); // Async signal safe logging mechanism. -BASE_API void RawLog(int level, const char* message); +BASE_EXPORT void RawLog(int level, const char* message); #define RAW_LOG(level, message) logging::RawLog(logging::LOG_ ## level, message) @@ -893,7 +893,7 @@ BASE_API void RawLog(int level, const char* message); // which is normally ASCII. It is relatively slow, so try not to use it for // common cases. Non-ASCII characters will be converted to UTF-8 by these // operators. -BASE_API std::ostream& operator<<(std::ostream& out, const wchar_t* wstr); +BASE_EXPORT std::ostream& operator<<(std::ostream& out, const wchar_t* wstr); inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) { return out << wstr.c_str(); } @@ -945,7 +945,7 @@ namespace base { class StringPiece; // Allows StringPiece to be logged. -BASE_API std::ostream& operator<<(std::ostream& o, const StringPiece& piece); +BASE_EXPORT std::ostream& operator<<(std::ostream& o, const StringPiece& piece); } // namespace base diff --git a/base/logging_win.h b/base/logging_win.h index bd69df9..d0758cd 100644 --- a/base/logging_win.h +++ b/base/logging_win.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/win/event_trace_provider.h" #include "base/logging.h" @@ -50,7 +50,7 @@ enum LogMessageTypes { // Trace provider class to drive log control and transport // with Event Tracing for Windows. -class BASE_API LogEventProvider : public base::win::EtwTraceProvider { +class BASE_EXPORT LogEventProvider : public base::win::EtwTraceProvider { public: static LogEventProvider* GetInstance(); diff --git a/base/mac/foundation_util.h b/base/mac/foundation_util.h index 37c2ff1..2e7757e 100644 --- a/base/mac/foundation_util.h +++ b/base/mac/foundation_util.h @@ -11,7 +11,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/logging.h" #if defined(__OBJC__) @@ -36,25 +36,25 @@ namespace base { namespace mac { // Returns true if the application is running from a bundle -BASE_API bool AmIBundled(); -BASE_API void SetOverrideAmIBundled(bool value); +BASE_EXPORT bool AmIBundled(); +BASE_EXPORT void SetOverrideAmIBundled(bool value); // Returns true if this process is marked as a "Background only process". -BASE_API bool IsBackgroundOnlyProcess(); +BASE_EXPORT bool IsBackgroundOnlyProcess(); // Returns the main bundle or the override, used for code that needs // to fetch resources from bundles, but work within a unittest where we // aren't a bundle. -BASE_API NSBundle* MainAppBundle(); -BASE_API FilePath MainAppBundlePath(); +BASE_EXPORT NSBundle* MainAppBundle(); +BASE_EXPORT FilePath MainAppBundlePath(); // Returns the path to a resource within the MainAppBundle. FilePath PathForMainAppBundleResource(CFStringRef resourceName); // Set the bundle that MainAppBundle will return, overriding the default value // (Restore the default by calling SetOverrideAppBundle(nil)). -BASE_API void SetOverrideAppBundle(NSBundle* bundle); -BASE_API void SetOverrideAppBundlePath(const FilePath& file_path); +BASE_EXPORT void SetOverrideAppBundle(NSBundle* bundle); +BASE_EXPORT void SetOverrideAppBundlePath(const FilePath& file_path); // Returns the creator code associated with the CFBundleRef at bundle. OSType CreatorCodeForCFBundleRef(CFBundleRef bundle); @@ -65,7 +65,7 @@ OSType CreatorCodeForCFBundleRef(CFBundleRef bundle); // does not respect the override app bundle because it's based on CFBundle // instead of NSBundle, and because callers probably don't want the override // app bundle's creator code anyway. -BASE_API OSType CreatorCodeForApplication(); +BASE_EXPORT OSType CreatorCodeForApplication(); // Searches for directories for the given key in only the given |domain_mask|. // If found, fills result (which must always be non-NULL) with the @@ -77,34 +77,34 @@ bool GetSearchPathDirectory(NSSearchPathDirectory directory, // Searches for directories for the given key in only the local domain. // If found, fills result (which must always be non-NULL) with the // first found directory and returns true. Otherwise, returns false. -BASE_API bool GetLocalDirectory(NSSearchPathDirectory directory, - FilePath* result); +BASE_EXPORT bool GetLocalDirectory(NSSearchPathDirectory directory, + FilePath* result); // Searches for directories for the given key in only the user domain. // If found, fills result (which must always be non-NULL) with the // first found directory and returns true. Otherwise, returns false. -BASE_API bool GetUserDirectory(NSSearchPathDirectory directory, - FilePath* result); +BASE_EXPORT bool GetUserDirectory(NSSearchPathDirectory directory, + FilePath* result); // Returns the ~/Library directory. -BASE_API FilePath GetUserLibraryPath(); +BASE_EXPORT FilePath GetUserLibraryPath(); // Takes a path to an (executable) binary and tries to provide the path to an // application bundle containing it. It takes the outermost bundle that it can // find (so for "/Foo/Bar.app/.../Baz.app/..." it produces "/Foo/Bar.app"). // |exec_name| - path to the binary // returns - path to the application bundle, or empty on error -BASE_API FilePath GetAppBundlePath(const FilePath& exec_name); +BASE_EXPORT FilePath GetAppBundlePath(const FilePath& exec_name); // Utility function to pull out a value from a dictionary, check its type, and // return it. Returns NULL if the key is not present or of the wrong type. -BASE_API CFTypeRef GetValueFromDictionary(CFDictionaryRef dict, - CFStringRef key, - CFTypeID expected_type); +BASE_EXPORT CFTypeRef GetValueFromDictionary(CFDictionaryRef dict, + CFStringRef key, + CFTypeID expected_type); // Retain/release calls for memory management in C++. -BASE_API void NSObjectRetain(void* obj); -BASE_API void NSObjectRelease(void* obj); +BASE_EXPORT void NSObjectRetain(void* obj); +BASE_EXPORT void NSObjectRelease(void* obj); // CFTypeRefToNSObjectAutorelease transfers ownership of a Core Foundation // object (one derived from CFTypeRef) to the Foundation memory management @@ -123,16 +123,16 @@ BASE_API void NSObjectRelease(void* obj); // returned NSObject. // // Returns an id, typed here for C++'s sake as a void*. -BASE_API void* CFTypeRefToNSObjectAutorelease(CFTypeRef cf_object); +BASE_EXPORT void* CFTypeRefToNSObjectAutorelease(CFTypeRef cf_object); // Returns the base bundle ID, which can be set by SetBaseBundleID but // defaults to a reasonable string. This never returns NULL. BaseBundleID // returns a pointer to static storage that must not be freed. -BASE_API const char* BaseBundleID(); +BASE_EXPORT const char* BaseBundleID(); // Sets the base bundle ID to override the default. The implementation will // make its own copy of new_base_bundle_id. -BASE_API void SetBaseBundleID(const char* new_base_bundle_id); +BASE_EXPORT void SetBaseBundleID(const char* new_base_bundle_id); } // namespace mac } // namespace base @@ -161,8 +161,8 @@ OBJC_CPP_CLASS_DECL(TypeNS) \ \ namespace base { \ namespace mac { \ -BASE_API TypeNS* CFToNSCast(TypeCF##Ref cf_val); \ -BASE_API TypeCF##Ref NSToCFCast(TypeNS* ns_val); \ +BASE_EXPORT TypeNS* CFToNSCast(TypeCF##Ref cf_val); \ +BASE_EXPORT TypeCF##Ref NSToCFCast(TypeNS* ns_val); \ } \ } \ @@ -172,8 +172,8 @@ OBJC_CPP_CLASS_DECL(NSMutable##name) \ \ namespace base { \ namespace mac { \ -BASE_API NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val); \ -BASE_API CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val); \ +BASE_EXPORT NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val); \ +BASE_EXPORT CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val); \ } \ } \ @@ -203,8 +203,9 @@ CF_TO_NS_CAST_DECL(CFURL, NSURL); // e.g. LOG(INFO) << base::mac::NSToCFCast(@"foo"); // Operator << can not be overloaded for ObjectiveC types as the compiler // can not distinguish between overloads for id with overloads for void*. -BASE_API extern std::ostream& operator<<(std::ostream& o, const CFErrorRef err); -BASE_API extern std::ostream& operator<<(std::ostream& o, - const CFStringRef str); +BASE_EXPORT extern std::ostream& operator<<(std::ostream& o, + const CFErrorRef err); +BASE_EXPORT extern std::ostream& operator<<(std::ostream& o, + const CFStringRef str); #endif // BASE_MAC_FOUNDATION_UTIL_H_ diff --git a/base/mac/mac_util.h b/base/mac/mac_util.h index 67151a7..e3ee0db 100644 --- a/base/mac/mac_util.h +++ b/base/mac/mac_util.h @@ -10,7 +10,7 @@ #include <Carbon/Carbon.h> #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/logging.h" // TODO(rohitrao): Clean up sites that include mac_util.h and remove this line. @@ -40,22 +40,22 @@ enum FullScreenMode { kFullScreenModeNormal = 10, }; -BASE_API std::string PathFromFSRef(const FSRef& ref); -BASE_API bool FSRefFromPath(const std::string& path, FSRef* ref); +BASE_EXPORT std::string PathFromFSRef(const FSRef& ref); +BASE_EXPORT bool FSRefFromPath(const std::string& path, FSRef* ref); // Returns an sRGB color space. The return value is a static value; do not // release it! -BASE_API CGColorSpaceRef GetSRGBColorSpace(); +BASE_EXPORT CGColorSpaceRef GetSRGBColorSpace(); // Returns the color space being used by the main display. The return value // is a static value; do not release it! -BASE_API CGColorSpaceRef GetSystemColorSpace(); +BASE_EXPORT CGColorSpaceRef GetSystemColorSpace(); // Add a full screen request for the given |mode|. Must be paired with a // ReleaseFullScreen() call for the same |mode|. This does not by itself create // a fullscreen window; rather, it manages per-application state related to // hiding the dock and menubar. Must be called on the main thread. -BASE_API void RequestFullScreen(FullScreenMode mode); +BASE_EXPORT void RequestFullScreen(FullScreenMode mode); // Release a request for full screen mode. Must be matched with a // RequestFullScreen() call for the same |mode|. As with RequestFullScreen(), @@ -63,45 +63,45 @@ BASE_API void RequestFullScreen(FullScreenMode mode); // state. For example, if there are no other outstanding // |kFullScreenModeAutoHideAll| requests, this will reshow the menu bar. Must // be called on main thread. -BASE_API void ReleaseFullScreen(FullScreenMode mode); +BASE_EXPORT void ReleaseFullScreen(FullScreenMode mode); // Convenience method to switch the current fullscreen mode. This has the same // net effect as a ReleaseFullScreen(from_mode) call followed immediately by a // RequestFullScreen(to_mode). Must be called on the main thread. -BASE_API void SwitchFullScreenModes(FullScreenMode from_mode, - FullScreenMode to_mode); +BASE_EXPORT void SwitchFullScreenModes(FullScreenMode from_mode, + FullScreenMode to_mode); // Set the visibility of the cursor. -BASE_API void SetCursorVisibility(bool visible); +BASE_EXPORT void SetCursorVisibility(bool visible); // Should windows miniaturize on a double-click (on the title bar)? -BASE_API bool ShouldWindowsMiniaturizeOnDoubleClick(); +BASE_EXPORT bool ShouldWindowsMiniaturizeOnDoubleClick(); // Activates the process with the given PID. -BASE_API void ActivateProcess(pid_t pid); +BASE_EXPORT void ActivateProcess(pid_t pid); // Returns true if this process is in the foreground, meaning that it's the // frontmost process, the one whose menu bar is shown at the top of the main // display. -BASE_API bool AmIForeground(); +BASE_EXPORT bool AmIForeground(); // Excludes the file given by |file_path| from being backed up by Time Machine. -BASE_API bool SetFileBackupExclusion(const FilePath& file_path); +BASE_EXPORT bool SetFileBackupExclusion(const FilePath& file_path); // Sets the process name as displayed in Activity Monitor to process_name. -BASE_API void SetProcessName(CFStringRef process_name); +BASE_EXPORT void SetProcessName(CFStringRef process_name); // Converts a NSImage to a CGImageRef. Normally, the system frameworks can do // this fine, especially on 10.6. On 10.5, however, CGImage cannot handle // converting a PDF-backed NSImage into a CGImageRef. This function will // rasterize the PDF into a bitmap CGImage. The caller is responsible for // releasing the return value. -BASE_API CGImageRef CopyNSImageToCGImage(NSImage* image); +BASE_EXPORT CGImageRef CopyNSImageToCGImage(NSImage* image); // Checks if the current application is set as a Login Item, so it will launch // on Login. If a non-NULL pointer to is_hidden is passed, the Login Item also // is queried for the 'hide on launch' flag. -BASE_API bool CheckLoginItemStatus(bool* is_hidden); +BASE_EXPORT bool CheckLoginItemStatus(bool* is_hidden); // Adds current application to the set of Login Items with specified "hide" // flag. This has the same effect as adding/removing the application in @@ -109,14 +109,14 @@ BASE_API bool CheckLoginItemStatus(bool* is_hidden); // as "Options->Open on Login". // Does nothing if the application is already set up as Login Item with // specified hide flag. -BASE_API void AddToLoginItems(bool hide_on_startup); +BASE_EXPORT void AddToLoginItems(bool hide_on_startup); // Removes the current application from the list Of Login Items. -BASE_API void RemoveFromLoginItems(); +BASE_EXPORT void RemoveFromLoginItems(); // Returns true if the current process was automatically launched as a // 'Login Item' with 'hide on startup' flag. Used to suppress opening windows. -BASE_API bool WasLaunchedAsHiddenLoginItem(); +BASE_EXPORT bool WasLaunchedAsHiddenLoginItem(); // Run-time OS version checks. Use these instead of // base::SysInfo::OperatingSystemVersionNumbers. Prefer the "OrEarlier" and @@ -124,22 +124,22 @@ BASE_API bool WasLaunchedAsHiddenLoginItem(); // know for sure that you need to check for a specific version. // Leopard is Mac OS X 10.5, Darwin 9. -BASE_API bool IsOSLeopard(); -BASE_API bool IsOSLeopardOrEarlier(); +BASE_EXPORT bool IsOSLeopard(); +BASE_EXPORT bool IsOSLeopardOrEarlier(); // Snow Leopard is Mac OS X 10.6, Darwin 10. -BASE_API bool IsOSSnowLeopard(); -BASE_API bool IsOSSnowLeopardOrEarlier(); -BASE_API bool IsOSSnowLeopardOrLater(); +BASE_EXPORT bool IsOSSnowLeopard(); +BASE_EXPORT bool IsOSSnowLeopardOrEarlier(); +BASE_EXPORT bool IsOSSnowLeopardOrLater(); // Lion is Mac OS X 10.7, Darwin 11. -BASE_API bool IsOSLion(); -BASE_API bool IsOSLionOrLater(); +BASE_EXPORT bool IsOSLion(); +BASE_EXPORT bool IsOSLionOrLater(); // This should be infrequently used. It only makes sense to use this to avoid // codepaths that are very likely to break on future (unreleased, untested, // unborn) OS releases. -BASE_API bool IsOSLaterThanLion(); +BASE_EXPORT bool IsOSLaterThanLion(); // When the deployment target is set, the code produced cannot run on earlier // OS releases. That enables some of the IsOS* family to be implemented as diff --git a/base/mac/objc_property_releaser.h b/base/mac/objc_property_releaser.h index 58c9b66..0772c43 100644 --- a/base/mac/objc_property_releaser.h +++ b/base/mac/objc_property_releaser.h @@ -8,7 +8,7 @@ #import <Foundation/Foundation.h> -#include "base/base_api.h" +#include "base/base_export.h" namespace base { namespace mac { @@ -83,7 +83,7 @@ namespace mac { // will only operate on instance variables in the immediate object in which // the property releaser is placed. -class BASE_API ObjCPropertyReleaser { +class BASE_EXPORT ObjCPropertyReleaser { public: // ObjCPropertyReleaser can only be owned by an Objective-C object, so its // memory is always guaranteed to be 0-initialized. Not defining the default diff --git a/base/mac/os_crash_dumps.h b/base/mac/os_crash_dumps.h index 6e74365..31d90fb 100644 --- a/base/mac/os_crash_dumps.h +++ b/base/mac/os_crash_dumps.h @@ -5,7 +5,7 @@ #ifndef BASE_MAC_OS_CRASH_DUMPS_H_ #define BASE_MAC_OS_CRASH_DUMPS_H_ -#include "base/base_api.h" +#include "base/base_export.h" namespace base { namespace mac { @@ -14,7 +14,7 @@ namespace mac { // process a Chrome crash when debugging symbols are available. This // translates into a long wait until the process actually dies. This call // disables Apple Crash Reporter entirely. -BASE_API void DisableOSCrashDumps(); +BASE_EXPORT void DisableOSCrashDumps(); } // namespace mac } // namespace base diff --git a/base/mac/scoped_nsautorelease_pool.h b/base/mac/scoped_nsautorelease_pool.h index 297b10a..3f73017 100644 --- a/base/mac/scoped_nsautorelease_pool.h +++ b/base/mac/scoped_nsautorelease_pool.h @@ -6,7 +6,7 @@ #define BASE_MAC_SCOPED_NSAUTORELEASE_POOL_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #if defined(OS_MACOSX) @@ -28,7 +28,7 @@ namespace mac { // On other platforms, ScopedNSAutoreleasePool is an empty object with no // effects. This allows it to be used directly in cross-platform code without // ugly #ifdefs. -class BASE_API ScopedNSAutoreleasePool { +class BASE_EXPORT ScopedNSAutoreleasePool { public: #if !defined(OS_MACOSX) ScopedNSAutoreleasePool() {} diff --git a/base/mac/scoped_nsexception_enabler.h b/base/mac/scoped_nsexception_enabler.h index a251fcc..3c16d2f 100644 --- a/base/mac/scoped_nsexception_enabler.h +++ b/base/mac/scoped_nsexception_enabler.h @@ -6,7 +6,7 @@ #define BASE_MAC_SCOPED_NSEXCEPTION_ENABLER_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -24,7 +24,7 @@ namespace mac { // top-level event loop, things are cleared in -reportException:. If // the exception is caught at a lower level, a higher level scoper // should eventually reset things. -class BASE_API ScopedNSExceptionEnabler { +class BASE_EXPORT ScopedNSExceptionEnabler { public: ScopedNSExceptionEnabler(); ~ScopedNSExceptionEnabler(); @@ -38,8 +38,8 @@ class BASE_API ScopedNSExceptionEnabler { // Access the exception setting for the current thread. This is for // the support code in BrowserCrApplication, other code should use // the scoper. -BASE_API bool GetNSExceptionsAllowed(); -BASE_API void SetNSExceptionsAllowed(bool allowed); +BASE_EXPORT bool GetNSExceptionsAllowed(); +BASE_EXPORT void SetNSExceptionsAllowed(bool allowed); } // namespace mac } // namespace base diff --git a/base/mach_ipc_mac.h b/base/mach_ipc_mac.h index 2ae7084..7d39101 100644 --- a/base/mach_ipc_mac.h +++ b/base/mach_ipc_mac.h @@ -13,7 +13,7 @@ #include <CoreServices/CoreServices.h> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" //============================================================================== @@ -139,7 +139,7 @@ class MachMsgPortDescriptor : public mach_msg_port_descriptor_t { // A MachMessage object is used by ReceivePort::WaitForMessage // and MachPortSender::SendMessage // -class BASE_API MachMessage { +class BASE_EXPORT MachMessage { public: static const size_t kEmptyMessageSize; @@ -245,7 +245,7 @@ class MachReceiveMessage : public MachMessage { }; //============================================================================== -class BASE_API MachSendMessage : public MachMessage { +class BASE_EXPORT MachSendMessage : public MachMessage { public: explicit MachSendMessage(int32_t message_id); MachSendMessage(void *storage, size_t storage_length, int32_t message_id); @@ -258,7 +258,7 @@ class BASE_API MachSendMessage : public MachMessage { //============================================================================== // Represents a Mach port for which we have receive rights -class BASE_API ReceivePort { +class BASE_EXPORT ReceivePort { public: // Creates a new Mach port for receiving messages and registers a name for it explicit ReceivePort(const char *receive_port_name); @@ -289,7 +289,7 @@ class BASE_API ReceivePort { //============================================================================== // Represents a Mach port for which we have send rights -class BASE_API MachPortSender { +class BASE_EXPORT MachPortSender { public: // get a port with send rights corresponding to a named registered service explicit MachPortSender(const char *receive_port_name); @@ -6,7 +6,7 @@ #define BASE_MD5_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string_piece.h" namespace base { @@ -45,25 +45,25 @@ typedef char MD5Context[88]; // Computes the MD5 sum of the given data buffer with the given length. // The given 'digest' structure will be filled with the result data. -BASE_API void MD5Sum(const void* data, size_t length, MD5Digest* digest); +BASE_EXPORT void MD5Sum(const void* data, size_t length, MD5Digest* digest); // Initializes the given MD5 context structure for subsequent calls to // MD5Update(). -BASE_API void MD5Init(MD5Context* context); +BASE_EXPORT void MD5Init(MD5Context* context); // For the given buffer of |data| as a StringPiece, updates the given MD5 // context with the sum of the data. You can call this any number of times // during the computation, except that MD5Init() must have been called first. -BASE_API void MD5Update(MD5Context* context, const StringPiece& data); +BASE_EXPORT void MD5Update(MD5Context* context, const StringPiece& data); // Finalizes the MD5 operation and fills the buffer with the digest. -BASE_API void MD5Final(MD5Digest* digest, MD5Context* context); +BASE_EXPORT void MD5Final(MD5Digest* digest, MD5Context* context); // Converts a digest into human-readable hexadecimal. -BASE_API std::string MD5DigestToBase16(const MD5Digest& digest); +BASE_EXPORT std::string MD5DigestToBase16(const MD5Digest& digest); // Returns the MD5 (in hexadecimal) of a string. -BASE_API std::string MD5String(const StringPiece& str); +BASE_EXPORT std::string MD5String(const StringPiece& str); } // namespace base diff --git a/base/memory/memory_debug.h b/base/memory/memory_debug.h index d094edb..740fb06 100644 --- a/base/memory/memory_debug.h +++ b/base/memory/memory_debug.h @@ -10,12 +10,12 @@ #define BASE_MEMORY_MEMORY_DEBUG_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { -class BASE_API MemoryDebug { +class BASE_EXPORT MemoryDebug { public: // Since MIU messages are a lot of data, and we don't always want this data, // we have a global switch. If disabled, *MemoryInUse are no-ops. diff --git a/base/memory/ref_counted.h b/base/memory/ref_counted.h index 1207ed4..439fda4 100644 --- a/base/memory/ref_counted.h +++ b/base/memory/ref_counted.h @@ -7,14 +7,14 @@ #pragma once #include "base/atomic_ref_count.h" -#include "base/base_api.h" +#include "base/base_export.h" #include "base/threading/thread_collision_warner.h" namespace base { namespace subtle { -class BASE_API RefCountedBase { +class BASE_EXPORT RefCountedBase { public: static bool ImplementsThreadSafeReferenceCounting() { return false; } @@ -40,7 +40,7 @@ class BASE_API RefCountedBase { DISALLOW_COPY_AND_ASSIGN(RefCountedBase); }; -class BASE_API RefCountedThreadSafeBase { +class BASE_EXPORT RefCountedThreadSafeBase { public: static bool ImplementsThreadSafeReferenceCounting() { return true; } diff --git a/base/memory/ref_counted_memory.h b/base/memory/ref_counted_memory.h index 7438d57..7b55d14 100644 --- a/base/memory/ref_counted_memory.h +++ b/base/memory/ref_counted_memory.h @@ -9,7 +9,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/compiler_specific.h" #include "base/memory/ref_counted.h" @@ -19,7 +19,7 @@ // A generic interface to memory. This object is reference counted because one // of its two subclasses own the data they carry, and we need to have // heterogeneous containers of these two types of memory. -class BASE_API RefCountedMemory +class BASE_EXPORT RefCountedMemory : public base::RefCountedThreadSafe<RefCountedMemory> { public: // Retrieves a pointer to the beginning of the data we point to. If the data @@ -37,7 +37,7 @@ class BASE_API RefCountedMemory // An implementation of RefCountedMemory, where the ref counting does not // matter. -class BASE_API RefCountedStaticMemory : public RefCountedMemory { +class BASE_EXPORT RefCountedStaticMemory : public RefCountedMemory { public: RefCountedStaticMemory() : data_(NULL), length_(0) {} @@ -57,7 +57,7 @@ class BASE_API RefCountedStaticMemory : public RefCountedMemory { // An implementation of RefCountedMemory, where we own our the data in a // vector. -class BASE_API RefCountedBytes : public RefCountedMemory { +class BASE_EXPORT RefCountedBytes : public RefCountedMemory { public: RefCountedBytes(); @@ -89,7 +89,7 @@ namespace base { // An implementation of RefCountedMemory, where the bytes are stored in an STL // string. Use this if your data naturally arrives in that format. -class BASE_API RefCountedString : public RefCountedMemory { +class BASE_EXPORT RefCountedString : public RefCountedMemory { public: RefCountedString(); diff --git a/base/memory/weak_ptr.h b/base/memory/weak_ptr.h index 0c6b4a7..abda1af 100644 --- a/base/memory/weak_ptr.h +++ b/base/memory/weak_ptr.h @@ -52,7 +52,7 @@ #define BASE_MEMORY_WEAK_PTR_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/logging.h" #include "base/memory/ref_counted.h" #include "base/threading/thread_checker.h" @@ -63,7 +63,7 @@ namespace internal { // These classes are part of the WeakPtr implementation. // DO NOT USE THESE CLASSES DIRECTLY YOURSELF. -class BASE_API WeakReference { +class BASE_EXPORT WeakReference { public: // While Flag is bound to a specific thread, it may be deleted from another // via base::WeakPtr::~WeakPtr(). @@ -95,7 +95,7 @@ class BASE_API WeakReference { scoped_refptr<Flag> flag_; }; -class BASE_API WeakReferenceOwner { +class BASE_EXPORT WeakReferenceOwner { public: WeakReferenceOwner(); ~WeakReferenceOwner(); @@ -121,7 +121,7 @@ class BASE_API WeakReferenceOwner { // constructor by avoiding the need for a public accessor for ref_. A // WeakPtr<T> cannot access the private members of WeakPtr<U>, so this // base class gives us a way to access ref_ in a protected fashion. -class BASE_API WeakPtrBase { +class BASE_EXPORT WeakPtrBase { public: WeakPtrBase(); ~WeakPtrBase(); diff --git a/base/message_loop.h b/base/message_loop.h index 540c74d..fd9fb7e 100644 --- a/base/message_loop.h +++ b/base/message_loop.h @@ -9,7 +9,7 @@ #include <queue> #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/callback.h" #include "base/memory/ref_counted.h" @@ -75,7 +75,7 @@ class Births; // Please be SURE your task is reentrant (nestable) and all global variables // are stable and accessible before calling SetNestableTasksAllowed(true). // -class BASE_API MessageLoop : public base::MessagePump::Delegate { +class BASE_EXPORT MessageLoop : public base::MessagePump::Delegate { public: #if defined(OS_WIN) typedef base::MessagePumpWin::Dispatcher Dispatcher; @@ -128,7 +128,7 @@ class BASE_API MessageLoop : public base::MessagePump::Delegate { // NOTE: Any tasks posted to the MessageLoop during this notification will // not be run. Instead, they will be deleted. // - class BASE_API DestructionObserver { + class BASE_EXPORT DestructionObserver { public: virtual void WillDestroyCurrentMessageLoop() = 0; @@ -317,7 +317,7 @@ class BASE_API MessageLoop : public base::MessagePump::Delegate { // MessageLoop. // // NOTE: A TaskObserver implementation should be extremely fast! - class BASE_API TaskObserver { + class BASE_EXPORT TaskObserver { public: TaskObserver(); @@ -383,7 +383,7 @@ class BASE_API MessageLoop : public base::MessagePump::Delegate { // MessagePumpForUI needs to keep the RunState. public: #endif - class BASE_API AutoRunState : RunState { + class BASE_EXPORT AutoRunState : RunState { public: explicit AutoRunState(MessageLoop* loop); ~AutoRunState(); @@ -580,7 +580,7 @@ class BASE_API MessageLoop : public base::MessagePump::Delegate { // This class is typically used like so: // MessageLoopForUI::current()->...call some method... // -class BASE_API MessageLoopForUI : public MessageLoop { +class BASE_EXPORT MessageLoopForUI : public MessageLoop { public: MessageLoopForUI() : MessageLoop(TYPE_UI) { } @@ -629,7 +629,7 @@ COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForUI), // This class is typically used like so: // MessageLoopForIO::current()->...call some method... // -class BASE_API MessageLoopForIO : public MessageLoop { +class BASE_EXPORT MessageLoopForIO : public MessageLoop { public: #if defined(OS_WIN) typedef base::MessagePumpForIO::IOHandler IOHandler; diff --git a/base/message_loop_proxy.h b/base/message_loop_proxy.h index d6955ba..646b2ef 100644 --- a/base/message_loop_proxy.h +++ b/base/message_loop_proxy.h @@ -6,7 +6,7 @@ #define BASE_MESSAGE_LOOP_PROXY_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/callback.h" #include "base/memory/ref_counted.h" @@ -20,7 +20,7 @@ struct MessageLoopProxyTraits; // of a message loop. This class can outlive the target message loop. You can // obtain a MessageLoopProxy via Thread::message_loop_proxy() or // MessageLoopProxy::CreateForCurrentThread(). -class BASE_API MessageLoopProxy +class BASE_EXPORT MessageLoopProxy : public base::RefCountedThreadSafe<MessageLoopProxy, MessageLoopProxyTraits> { public: diff --git a/base/message_loop_proxy_impl.h b/base/message_loop_proxy_impl.h index 4c04148..57896ff 100644 --- a/base/message_loop_proxy_impl.h +++ b/base/message_loop_proxy_impl.h @@ -6,7 +6,7 @@ #define BASE_MESSAGE_LOOP_PROXY_IMPL_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/message_loop.h" #include "base/message_loop_proxy.h" #include "base/synchronization/lock.h" @@ -16,8 +16,9 @@ namespace base { // A stock implementation of MessageLoopProxy that takes in a MessageLoop // and keeps track of its lifetime using the MessageLoop DestructionObserver. // For now a MessageLoopProxyImpl can only be created for the current thread. -class BASE_API MessageLoopProxyImpl : public MessageLoopProxy, - public MessageLoop::DestructionObserver { +class BASE_EXPORT MessageLoopProxyImpl + : public MessageLoopProxy, + public MessageLoop::DestructionObserver { public: virtual ~MessageLoopProxyImpl(); diff --git a/base/message_pump.h b/base/message_pump.h index 6a48e81..d7aaf0c 100644 --- a/base/message_pump.h +++ b/base/message_pump.h @@ -6,18 +6,18 @@ #define BASE_MESSAGE_PUMP_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/memory/ref_counted.h" namespace base { class TimeTicks; -class BASE_API MessagePump : public RefCountedThreadSafe<MessagePump> { +class BASE_EXPORT MessagePump : public RefCountedThreadSafe<MessagePump> { public: // Please see the comments above the Run method for an illustration of how // these delegate methods are used. - class BASE_API Delegate { + class BASE_EXPORT Delegate { public: virtual ~Delegate() {} diff --git a/base/message_pump_gtk.h b/base/message_pump_gtk.h index 5fa21f7..80122ce 100644 --- a/base/message_pump_gtk.h +++ b/base/message_pump_gtk.h @@ -41,7 +41,7 @@ class MessagePumpDispatcher { }; // This class implements a message-pump for dispatching GTK events. -class BASE_API MessagePumpGtk : public MessagePumpGlib { +class BASE_EXPORT MessagePumpGtk : public MessagePumpGlib { public: MessagePumpGtk(); virtual ~MessagePumpGtk(); diff --git a/base/message_pump_libevent.h b/base/message_pump_libevent.h index fd76379..2af3bcc 100644 --- a/base/message_pump_libevent.h +++ b/base/message_pump_libevent.h @@ -21,7 +21,7 @@ namespace base { // Class to monitor sockets and issue callbacks when sockets are ready for I/O // TODO(dkegel): add support for background file IO somehow -class BASE_API MessagePumpLibevent : public MessagePump { +class BASE_EXPORT MessagePumpLibevent : public MessagePump { public: class IOObserver { public: diff --git a/base/message_pump_win.h b/base/message_pump_win.h index 721074f..5f17610 100644 --- a/base/message_pump_win.h +++ b/base/message_pump_win.h @@ -10,7 +10,7 @@ #include <list> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/message_pump.h" #include "base/observer_list.h" @@ -22,14 +22,14 @@ namespace base { // MessagePumpWin serves as the base for specialized versions of the MessagePump // for Windows. It provides basic functionality like handling of observers and // controlling the lifetime of the message pump. -class BASE_API MessagePumpWin : public MessagePump { +class BASE_EXPORT MessagePumpWin : public MessagePump { public: // An Observer is an object that receives global notifications from the // UI MessageLoop. // // NOTE: An Observer implementation should be extremely fast! // - class BASE_API Observer { + class BASE_EXPORT Observer { public: virtual ~Observer() {} @@ -50,7 +50,7 @@ class BASE_API MessagePumpWin : public MessagePump { // // The nested loop is exited by either posting a quit, or returning false // from Dispatch. - class BASE_API Dispatcher { + class BASE_EXPORT Dispatcher { public: virtual ~Dispatcher() {} // Dispatches the event. If true is returned processing continues as @@ -157,7 +157,7 @@ class BASE_API MessagePumpWin : public MessagePump { // an excellent choice. It is also helpful that the starter messages that are // placed in the queue when new task arrive also awakens DoRunLoop. // -class BASE_API MessagePumpForUI : public MessagePumpWin { +class BASE_EXPORT MessagePumpForUI : public MessagePumpWin { public: // The application-defined code passed to the hook procedure. static const int kMessageFilterCode = 0x5001; @@ -196,7 +196,7 @@ class BASE_API MessagePumpForUI : public MessagePumpWin { // deal with Windows mesagges, and instead has a Run loop based on Completion // Ports so it is better suited for IO operations. // -class BASE_API MessagePumpForIO : public MessagePumpWin { +class BASE_EXPORT MessagePumpForIO : public MessagePumpWin { public: struct IOContext; diff --git a/base/message_pump_x.h b/base/message_pump_x.h index 49a8251..a6b68c6 100644 --- a/base/message_pump_x.h +++ b/base/message_pump_x.h @@ -19,7 +19,7 @@ typedef struct _XDisplay Display; namespace base { // The documentation for this class is in message_pump_glib.h -class BASE_API MessagePumpObserver { +class BASE_EXPORT MessagePumpObserver { public: enum EventStatus { EVENT_CONTINUE, // The event should be dispatched as normal. @@ -59,7 +59,7 @@ class MessagePumpDispatcher { }; // This class implements a message-pump for dispatching X events. -class BASE_API MessagePumpX : public MessagePumpGlib { +class BASE_EXPORT MessagePumpX : public MessagePumpGlib { public: MessagePumpX(); virtual ~MessagePumpX(); diff --git a/base/metrics/field_trial.h b/base/metrics/field_trial.h index 3b831d8..87b412b 100644 --- a/base/metrics/field_trial.h +++ b/base/metrics/field_trial.h @@ -78,7 +78,7 @@ #include <map> #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/gtest_prod_util.h" #include "base/memory/ref_counted.h" #include "base/observer_list.h" @@ -89,7 +89,7 @@ namespace base { class FieldTrialList; -class BASE_API FieldTrial : public RefCounted<FieldTrial> { +class BASE_EXPORT FieldTrial : public RefCounted<FieldTrial> { public: typedef int Probability; // Probability type for being selected in a trial. @@ -239,7 +239,7 @@ class BASE_API FieldTrial : public RefCounted<FieldTrial> { // Class with a list of all active field trials. A trial is active if it has // been registered, which includes evaluating its state based on its probaility. // Only one instance of this class exists. -class BASE_API FieldTrialList { +class BASE_EXPORT FieldTrialList { public: // Define a separator charactor to use when creating a persistent form of an // instance. This is intended for use as a command line argument, passed to a diff --git a/base/metrics/histogram.h b/base/metrics/histogram.h index 29004e4..23740f9 100644 --- a/base/metrics/histogram.h +++ b/base/metrics/histogram.h @@ -45,7 +45,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/gtest_prod_util.h" #include "base/logging.h" #include "base/time.h" @@ -266,7 +266,7 @@ class CustomHistogram; class Histogram; class LinearHistogram; -class BASE_API Histogram { +class BASE_EXPORT Histogram { public: typedef int Sample; // Used for samples (and ranges of samples). typedef int Count; // Used to count samples in a bucket. @@ -325,7 +325,7 @@ class BASE_API Histogram { //---------------------------------------------------------------------------- // Statistic values, developed over the life of the histogram. - class BASE_API SampleSet { + class BASE_EXPORT SampleSet { public: explicit SampleSet(); ~SampleSet(); @@ -584,7 +584,7 @@ class BASE_API Histogram { // LinearHistogram is a more traditional histogram, with evenly spaced // buckets. -class BASE_API LinearHistogram : public Histogram { +class BASE_EXPORT LinearHistogram : public Histogram { public: virtual ~LinearHistogram(); @@ -640,7 +640,7 @@ class BASE_API LinearHistogram : public Histogram { //------------------------------------------------------------------------------ // BooleanHistogram is a histogram for booleans. -class BASE_API BooleanHistogram : public LinearHistogram { +class BASE_EXPORT BooleanHistogram : public LinearHistogram { public: static Histogram* FactoryGet(const std::string& name, Flags flags); @@ -657,7 +657,7 @@ class BASE_API BooleanHistogram : public LinearHistogram { //------------------------------------------------------------------------------ // CustomHistogram is a histogram for a set of custom integers. -class BASE_API CustomHistogram : public Histogram { +class BASE_EXPORT CustomHistogram : public Histogram { public: static Histogram* FactoryGet(const std::string& name, @@ -691,7 +691,7 @@ class BASE_API CustomHistogram : public Histogram { // general place for histograms to register, and supports a global API for // accessing (i.e., dumping, or graphing) the data in all the histograms. -class BASE_API StatisticsRecorder { +class BASE_EXPORT StatisticsRecorder { public: typedef std::vector<Histogram*> Histograms; diff --git a/base/metrics/stats_counters.h b/base/metrics/stats_counters.h index f40dcbe..9ba3517 100644 --- a/base/metrics/stats_counters.h +++ b/base/metrics/stats_counters.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/metrics/stats_table.h" #include "base/time.h" @@ -75,7 +75,7 @@ namespace base { //------------------------------------------------------------------------------ // StatsCounter represents a counter in the StatsTable class. -class BASE_API StatsCounter { +class BASE_EXPORT StatsCounter { public: // Create a StatsCounter object. explicit StatsCounter(const std::string& name); @@ -129,7 +129,7 @@ class BASE_API StatsCounter { // A StatsCounterTimer is a StatsCounter which keeps a timer during // the scope of the StatsCounterTimer. On destruction, it will record // its time measurement. -class BASE_API StatsCounterTimer : protected StatsCounter { +class BASE_EXPORT StatsCounterTimer : protected StatsCounter { public: // Constructs and starts the timer. explicit StatsCounterTimer(const std::string& name); @@ -158,7 +158,7 @@ class BASE_API StatsCounterTimer : protected StatsCounter { // A StatsRate is a timer that keeps a count of the number of intervals added so // that several statistics can be produced: // min, max, avg, count, total -class BASE_API StatsRate : public StatsCounterTimer { +class BASE_EXPORT StatsRate : public StatsCounterTimer { public: // Constructs and starts the timer. explicit StatsRate(const std::string& name); diff --git a/base/metrics/stats_table.h b/base/metrics/stats_table.h index c8ebae7..6368dd7 100644 --- a/base/metrics/stats_table.h +++ b/base/metrics/stats_table.h @@ -23,7 +23,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/hash_tables.h" #include "base/synchronization/lock.h" @@ -31,7 +31,7 @@ namespace base { -class BASE_API StatsTable { +class BASE_EXPORT StatsTable { public: // Create a new StatsTable. // If a StatsTable already exists with the specified name, this StatsTable diff --git a/base/mime_util.h b/base/mime_util.h index 0e0a242..fd862ed 100644 --- a/base/mime_util.h +++ b/base/mime_util.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "build/build_config.h" class FilePath; @@ -19,23 +19,23 @@ namespace mime_util { // have to exist. Please note because it doesn't touch the disk, this does not // work for directories. // If the mime type is unknown, this will return application/octet-stream. -BASE_API std::string GetFileMimeType(const FilePath& filepath); +BASE_EXPORT std::string GetFileMimeType(const FilePath& filepath); // Get the mime type for a byte vector. -BASE_API std::string GetDataMimeType(const std::string& data); +BASE_EXPORT std::string GetDataMimeType(const std::string& data); #if defined(TOOLKIT_GTK) // This detects the current GTK theme by calling gtk_settings_get_default(). // It should only be executed on the UI thread and must be called before // GetMimeIcon(). -BASE_API void DetectGtkTheme(); +BASE_EXPORT void DetectGtkTheme(); #endif // Gets the file name for an icon given the mime type and icon pixel size. // Where an icon is a square image of |size| x |size|. // This will try to find the closest matching icon. If that's not available, // then a generic icon, and finally an empty FilePath if all else fails. -BASE_API FilePath GetMimeIcon(const std::string& mime_type, size_t size); +BASE_EXPORT FilePath GetMimeIcon(const std::string& mime_type, size_t size); } // namespace mime_util diff --git a/base/native_library.h b/base/native_library.h index 2896163..1e0dfcd 100644 --- a/base/native_library.h +++ b/base/native_library.h @@ -9,7 +9,7 @@ // This file defines a cross-platform "NativeLibrary" type which represents // a loadable module. -#include "base/base_api.h" +#include "base/base_export.h" #include "build/build_config.h" #if defined(OS_WIN) @@ -55,8 +55,8 @@ typedef void* NativeLibrary; // you're done. Returns NULL on failure. // If |err| is not NULL, it may be filled in with an error message on // error. -BASE_API NativeLibrary LoadNativeLibrary(const FilePath& library_path, - std::string* error); +BASE_EXPORT NativeLibrary LoadNativeLibrary(const FilePath& library_path, + std::string* error); #if defined(OS_WIN) // Loads a native library from disk. Release it with UnloadNativeLibrary when @@ -64,22 +64,22 @@ BASE_API NativeLibrary LoadNativeLibrary(const FilePath& library_path, // This function retrieves the LoadLibrary function exported from kernel32.dll // and calls it instead of directly calling the LoadLibrary function via the // import table. -BASE_API NativeLibrary LoadNativeLibraryDynamically( +BASE_EXPORT NativeLibrary LoadNativeLibraryDynamically( const FilePath& library_path); #endif // OS_WIN // Unloads a native library. -BASE_API void UnloadNativeLibrary(NativeLibrary library); +BASE_EXPORT void UnloadNativeLibrary(NativeLibrary library); // Gets a function pointer from a native library. -BASE_API void* GetFunctionPointerFromNativeLibrary(NativeLibrary library, - const char* name); +BASE_EXPORT void* GetFunctionPointerFromNativeLibrary(NativeLibrary library, + const char* name); // Returns the full platform specific name for a native library. // For example: // "mylib" returns "mylib.dll" on Windows, "libmylib.so" on Linux, // "mylib.dylib" on Mac. -BASE_API string16 GetNativeLibraryName(const string16& name); +BASE_EXPORT string16 GetNativeLibraryName(const string16& name); } // namespace base diff --git a/base/nix/xdg_util.h b/base/nix/xdg_util.h index 8420a9e..305a679 100644 --- a/base/nix/xdg_util.h +++ b/base/nix/xdg_util.h @@ -13,7 +13,7 @@ // net. We should have a net API to allow the embedder to specify the behavior // that it uses XDG for, and then move this file. -#include "base/base_api.h" +#include "base/base_export.h" #ifdef nix #error asdf @@ -32,14 +32,14 @@ namespace nix { // a directory path. |fallback_dir| is the directory relative to $HOME that we // use if |env_name| cannot be found or is empty. |fallback_dir| may be NULL. // Examples of |env_name| are XDG_CONFIG_HOME and XDG_DATA_HOME. -BASE_API FilePath GetXDGDirectory(Environment* env, const char* env_name, - const char* fallback_dir); +BASE_EXPORT FilePath GetXDGDirectory(Environment* env, const char* env_name, + const char* fallback_dir); // Wrapper around xdg_user_dir_lookup() from src/base/third_party/xdg-user-dirs // This looks up "well known" user directories like the desktop and music // folder. Examples of |dir_name| are DESKTOP and MUSIC. -BASE_API FilePath GetXDGUserDirectory(Environment* env, const char* dir_name, - const char* fallback_dir); +BASE_EXPORT FilePath GetXDGUserDirectory(Environment* env, const char* dir_name, + const char* fallback_dir); enum DesktopEnvironment { DESKTOP_ENVIRONMENT_OTHER, @@ -55,13 +55,13 @@ enum DesktopEnvironment { // of which desktop environment we're using. We use this to know when // to attempt to use preferences from the desktop environment -- // proxy settings, password manager, etc. -BASE_API DesktopEnvironment GetDesktopEnvironment(Environment* env); +BASE_EXPORT DesktopEnvironment GetDesktopEnvironment(Environment* env); // Return a string representation of the given desktop environment. // May return NULL in the case of DESKTOP_ENVIRONMENT_OTHER. -BASE_API const char* GetDesktopEnvironmentName(DesktopEnvironment env); +BASE_EXPORT const char* GetDesktopEnvironmentName(DesktopEnvironment env); // Convenience wrapper that calls GetDesktopEnvironment() first. -BASE_API const char* GetDesktopEnvironmentName(Environment* env); +BASE_EXPORT const char* GetDesktopEnvironmentName(Environment* env); } // namespace nix } // namespace base diff --git a/base/path_service.h b/base/path_service.h index 284fbf7..4b29738 100644 --- a/base/path_service.h +++ b/base/path_service.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/base_paths.h" #include "build/build_config.h" @@ -17,7 +17,7 @@ class FilePath; // The path service is a global table mapping keys to file system paths. It is // OK to use this service from multiple threads. // -class BASE_API PathService { +class BASE_EXPORT PathService { public: // Retrieves a path to a special directory or file and places it into the // string pointed to by 'path'. If you ask for a directory it is guaranteed diff --git a/base/pickle.h b/base/pickle.h index 20878e0..d93fe86 100644 --- a/base/pickle.h +++ b/base/pickle.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/gtest_prod_util.h" #include "base/logging.h" @@ -31,7 +31,7 @@ // space is controlled by the header_size parameter passed to the Pickle // constructor. // -class BASE_API Pickle { +class BASE_EXPORT Pickle { public: // Initialize a Pickle object using the default header size. Pickle(); diff --git a/base/platform_file.h b/base/platform_file.h index afe909a..856ec8e 100644 --- a/base/platform_file.h +++ b/base/platform_file.h @@ -13,7 +13,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/file_path.h" #include "base/time.h" @@ -81,7 +81,7 @@ enum PlatformFileError { // make sure to update all functions that use it in file_util_{win|posix}.cc // too, and the ParamTraits<base::PlatformFileInfo> implementation in // chrome/common/common_param_traits.cc. -struct BASE_API PlatformFileInfo { +struct BASE_EXPORT PlatformFileInfo { PlatformFileInfo(); ~PlatformFileInfo(); @@ -108,39 +108,40 @@ struct BASE_API PlatformFileInfo { // true if a new file was created [or an old one truncated to zero length to // simulate a new file, which can happen with PLATFORM_FILE_CREATE_ALWAYS], and // false otherwise. |error_code| can be NULL. -BASE_API PlatformFile CreatePlatformFile(const FilePath& name, - int flags, - bool* created, - PlatformFileError* error_code); +BASE_EXPORT PlatformFile CreatePlatformFile(const FilePath& name, + int flags, + bool* created, + PlatformFileError* error_code); // Closes a file handle. Returns |true| on success and |false| otherwise. -BASE_API bool ClosePlatformFile(PlatformFile file); +BASE_EXPORT bool ClosePlatformFile(PlatformFile file); // Reads the given number of bytes (or until EOF is reached) starting with the // given offset. Returns the number of bytes read, or -1 on error. -BASE_API int ReadPlatformFile(PlatformFile file, int64 offset, - char* data, int size); +BASE_EXPORT int ReadPlatformFile(PlatformFile file, int64 offset, + char* data, int size); // Writes the given buffer into the file at the given offset, overwritting any // data that was previously there. Returns the number of bytes written, or -1 // on error. -BASE_API int WritePlatformFile(PlatformFile file, int64 offset, - const char* data, int size); +BASE_EXPORT int WritePlatformFile(PlatformFile file, int64 offset, + const char* data, int size); // Truncates the given file to the given length. If |length| is greater than // the current size of the file, the file is extended with zeros. If the file // doesn't exist, |false| is returned. -BASE_API bool TruncatePlatformFile(PlatformFile file, int64 length); +BASE_EXPORT bool TruncatePlatformFile(PlatformFile file, int64 length); // Flushes the buffers of the given file. -BASE_API bool FlushPlatformFile(PlatformFile file); +BASE_EXPORT bool FlushPlatformFile(PlatformFile file); // Touches the given file. -BASE_API bool TouchPlatformFile(PlatformFile file, const Time& last_access_time, - const Time& last_modified_time); +BASE_EXPORT bool TouchPlatformFile(PlatformFile file, + const Time& last_access_time, + const Time& last_modified_time); // Returns some information for the given file. -BASE_API bool GetPlatformFileInfo(PlatformFile file, PlatformFileInfo* info); +BASE_EXPORT bool GetPlatformFileInfo(PlatformFile file, PlatformFileInfo* info); // Use this class to pass ownership of a PlatformFile to a receiver that may or // may not want to accept it. This class does not own the storage for the @@ -162,7 +163,7 @@ BASE_API bool GetPlatformFileInfo(PlatformFile file, PlatformFileInfo* info); // ClosePlatformFile(file); // } // -class BASE_API PassPlatformFile { +class BASE_EXPORT PassPlatformFile { public: explicit PassPlatformFile(PlatformFile* value) : value_(value) { } diff --git a/base/process.h b/base/process.h index 9b1519a..2670924 100644 --- a/base/process.h +++ b/base/process.h @@ -6,7 +6,7 @@ #define BASE_PROCESS_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "build/build_config.h" @@ -40,7 +40,7 @@ const ProcessId kNullProcessId = 0; const int kUnsetProcessPriority = 256; #endif -class BASE_API Process { +class BASE_EXPORT Process { public: Process() : process_(kNullProcessHandle) { #if defined(OS_POSIX) && !defined(OS_MACOSX) diff --git a/base/process_util.h b/base/process_util.h index 5f88c62..acaa2d7 100644 --- a/base/process_util.h +++ b/base/process_util.h @@ -33,7 +33,7 @@ typedef struct _malloc_zone_t malloc_zone_t; #include <utility> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/file_descriptor_shuffle.h" #include "base/file_path.h" #include "base/process.h" @@ -132,14 +132,14 @@ enum TerminationStatus { }; // Returns the id of the current process. -BASE_API ProcessId GetCurrentProcId(); +BASE_EXPORT ProcessId GetCurrentProcId(); // Returns the ProcessHandle of the current process. -BASE_API ProcessHandle GetCurrentProcessHandle(); +BASE_EXPORT ProcessHandle GetCurrentProcessHandle(); // Converts a PID to a process handle. This handle must be closed by // CloseProcessHandle when you are done with it. Returns true on success. -BASE_API bool OpenProcessHandle(ProcessId pid, ProcessHandle* handle); +BASE_EXPORT bool OpenProcessHandle(ProcessId pid, ProcessHandle* handle); // Converts a PID to a process handle. On Windows the handle is opened // with more access rights and must only be used by trusted code. @@ -147,47 +147,48 @@ BASE_API bool OpenProcessHandle(ProcessId pid, ProcessHandle* handle); // on success. // TODO(sanjeevr): Replace all calls to OpenPrivilegedProcessHandle with the // more specific OpenProcessHandleWithAccess method and delete this. -BASE_API bool OpenPrivilegedProcessHandle(ProcessId pid, ProcessHandle* handle); +BASE_EXPORT bool OpenPrivilegedProcessHandle(ProcessId pid, + ProcessHandle* handle); // Converts a PID to a process handle using the desired access flags. Use a // combination of the kProcessAccess* flags defined above for |access_flags|. -BASE_API bool OpenProcessHandleWithAccess(ProcessId pid, - uint32 access_flags, - ProcessHandle* handle); +BASE_EXPORT bool OpenProcessHandleWithAccess(ProcessId pid, + uint32 access_flags, + ProcessHandle* handle); // Closes the process handle opened by OpenProcessHandle. -BASE_API void CloseProcessHandle(ProcessHandle process); +BASE_EXPORT void CloseProcessHandle(ProcessHandle process); // Returns the unique ID for the specified process. This is functionally the // same as Windows' GetProcessId(), but works on versions of Windows before // Win XP SP1 as well. -BASE_API ProcessId GetProcId(ProcessHandle process); +BASE_EXPORT ProcessId GetProcId(ProcessHandle process); #if defined(OS_LINUX) // Returns the path to the executable of the given process. -BASE_API FilePath GetProcessExecutablePath(ProcessHandle process); +BASE_EXPORT FilePath GetProcessExecutablePath(ProcessHandle process); // Parse the data found in /proc/<pid>/stat and return the sum of the // CPU-related ticks. Returns -1 on parse error. // Exposed for testing. -BASE_API int ParseProcStatCPU(const std::string& input); +BASE_EXPORT int ParseProcStatCPU(const std::string& input); static const char kAdjustOOMScoreSwitch[] = "--adjust-oom-score"; // This adjusts /proc/process/oom_adj so the Linux OOM killer will prefer // certain process types over others. The range for the adjustment is // [-17,15], with [0,15] being user accessible. -BASE_API bool AdjustOOMScore(ProcessId process, int score); +BASE_EXPORT bool AdjustOOMScore(ProcessId process, int score); #endif #if defined(OS_POSIX) // Returns the ID for the parent of the given process. -BASE_API ProcessId GetParentProcessId(ProcessHandle process); +BASE_EXPORT ProcessId GetParentProcessId(ProcessHandle process); // Close all file descriptors, except those which are a destination in the // given multimap. Only call this function in a child process where you know // that there aren't any other threads. -BASE_API void CloseSuperfluousFds(const InjectiveMultimap& saved_map); +BASE_EXPORT void CloseSuperfluousFds(const InjectiveMultimap& saved_map); #endif // TODO(evan): rename these to use StudlyCaps. @@ -263,9 +264,9 @@ struct LaunchOptions { // close-on-exec. // - If the first argument on the command line does not contain a slash, // PATH will be searched. (See man execvp.) -BASE_API bool LaunchProcess(const CommandLine& cmdline, - const LaunchOptions& options, - ProcessHandle* process_handle); +BASE_EXPORT bool LaunchProcess(const CommandLine& cmdline, + const LaunchOptions& options, + ProcessHandle* process_handle); #if defined(OS_WIN) @@ -278,8 +279,8 @@ enum IntegrityLevel { // Determine the integrity level of the specified process. Returns false // if the system does not support integrity levels (pre-Vista) or in the case // of an underlying system failure. -BASE_API bool GetProcessIntegrityLevel(ProcessHandle process, - IntegrityLevel *level); +BASE_EXPORT bool GetProcessIntegrityLevel(ProcessHandle process, + IntegrityLevel *level); // Windows-specific LaunchProcess that takes the command line as a // string. Useful for situations where you need to control the @@ -291,18 +292,18 @@ BASE_API bool GetProcessIntegrityLevel(ProcessHandle process, // // Example (including literal quotes) // cmdline = "c:\windows\explorer.exe" -foo "c:\bar\" -BASE_API bool LaunchProcess(const string16& cmdline, - const LaunchOptions& options, - ProcessHandle* process_handle); +BASE_EXPORT bool LaunchProcess(const string16& cmdline, + const LaunchOptions& options, + ProcessHandle* process_handle); #elif defined(OS_POSIX) // A POSIX-specific version of LaunchProcess that takes an argv array // instead of a CommandLine. Useful for situations where you need to // control the command line arguments directly, but prefer the // CommandLine version if launching Chrome itself. -BASE_API bool LaunchProcess(const std::vector<std::string>& argv, - const LaunchOptions& options, - ProcessHandle* process_handle); +BASE_EXPORT bool LaunchProcess(const std::vector<std::string>& argv, + const LaunchOptions& options, + ProcessHandle* process_handle); // AlterEnvironment returns a modified environment vector, constructed from the // given environment and the list of changes given in |changes|. Each key in @@ -311,29 +312,29 @@ BASE_API bool LaunchProcess(const std::vector<std::string>& argv, // the second is empty, in which case the key-value is removed. // // The returned array is allocated using new[] and must be freed by the caller. -BASE_API char** AlterEnvironment(const environment_vector& changes, - const char* const* const env); +BASE_EXPORT char** AlterEnvironment(const environment_vector& changes, + const char* const* const env); #endif // defined(OS_POSIX) // Executes the application specified by |cl| and wait for it to exit. Stores // the output (stdout) in |output|. Redirects stderr to /dev/null. Returns true // on success (application launched and exited cleanly, with exit code // indicating success). -BASE_API bool GetAppOutput(const CommandLine& cl, std::string* output); +BASE_EXPORT bool GetAppOutput(const CommandLine& cl, std::string* output); #if defined(OS_POSIX) // A restricted version of |GetAppOutput()| which (a) clears the environment, // and (b) stores at most |max_output| bytes; also, it doesn't search the path // for the command. -BASE_API bool GetAppOutputRestricted(const CommandLine& cl, - std::string* output, size_t max_output); +BASE_EXPORT bool GetAppOutputRestricted(const CommandLine& cl, + std::string* output, size_t max_output); // A version of |GetAppOutput()| which also returns the exit code of the // executed command. Returns true if the application runs and exits cleanly. If // this is the case the exit code of the application is available in // |*exit_code|. -BASE_API bool GetAppOutputWithExitCode(const CommandLine& cl, - std::string* output, int* exit_code); +BASE_EXPORT bool GetAppOutputWithExitCode(const CommandLine& cl, + std::string* output, int* exit_code); #endif // Used to filter processes by process ID. @@ -350,31 +351,32 @@ class ProcessFilter { // Returns the number of processes on the machine that are running from the // given executable name. If filter is non-null, then only processes selected // by the filter will be counted. -BASE_API int GetProcessCount(const FilePath::StringType& executable_name, - const ProcessFilter* filter); +BASE_EXPORT int GetProcessCount(const FilePath::StringType& executable_name, + const ProcessFilter* filter); // Attempts to kill all the processes on the current machine that were launched // from the given executable name, ending them with the given exit code. If // filter is non-null, then only processes selected by the filter are killed. // Returns true if all processes were able to be killed off, false if at least // one couldn't be killed. -BASE_API bool KillProcesses(const FilePath::StringType& executable_name, - int exit_code, const ProcessFilter* filter); +BASE_EXPORT bool KillProcesses(const FilePath::StringType& executable_name, + int exit_code, const ProcessFilter* filter); // Attempts to kill the process identified by the given process // entry structure, giving it the specified exit code. If |wait| is true, wait // for the process to be actually terminated before returning. // Returns true if this is successful, false otherwise. -BASE_API bool KillProcess(ProcessHandle process, int exit_code, bool wait); +BASE_EXPORT bool KillProcess(ProcessHandle process, int exit_code, bool wait); #if defined(OS_POSIX) // Attempts to kill the process group identified by |process_group_id|. Returns // true on success. -BASE_API bool KillProcessGroup(ProcessHandle process_group_id); +BASE_EXPORT bool KillProcessGroup(ProcessHandle process_group_id); #endif #if defined(OS_WIN) -BASE_API bool KillProcessById(ProcessId process_id, int exit_code, bool wait); +BASE_EXPORT bool KillProcessById(ProcessId process_id, int exit_code, + bool wait); #endif // Get the termination status of the process by interpreting the @@ -385,14 +387,14 @@ BASE_API bool KillProcessById(ProcessId process_id, int exit_code, bool wait); // will only return a useful result the first time it is called after // the child exits (because it will reap the child and the information // will no longer be available). -BASE_API TerminationStatus GetTerminationStatus(ProcessHandle handle, - int* exit_code); +BASE_EXPORT TerminationStatus GetTerminationStatus(ProcessHandle handle, + int* exit_code); // Waits for process to exit. On POSIX systems, if the process hasn't been // signaled then puts the exit code in |exit_code|; otherwise it's considered // a failure. On Windows |exit_code| is always filled. Returns true on success, // and closes |handle| in any case. -BASE_API bool WaitForExitCode(ProcessHandle handle, int* exit_code); +BASE_EXPORT bool WaitForExitCode(ProcessHandle handle, int* exit_code); // Waits for process to exit. If it did exit within |timeout_milliseconds|, // then puts the exit code in |exit_code|, and returns true. @@ -400,14 +402,15 @@ BASE_API bool WaitForExitCode(ProcessHandle handle, int* exit_code); // to -1. Returns false on failure (the caller is then responsible for closing // |handle|). // The caller is always responsible for closing the |handle|. -BASE_API bool WaitForExitCodeWithTimeout(ProcessHandle handle, int* exit_code, - int64 timeout_milliseconds); +BASE_EXPORT bool WaitForExitCodeWithTimeout(ProcessHandle handle, + int* exit_code, + int64 timeout_milliseconds); // Wait for all the processes based on the named executable to exit. If filter // is non-null, then only processes selected by the filter are waited on. // Returns after all processes have exited or wait_milliseconds have expired. // Returns true if all the processes exited, false otherwise. -BASE_API bool WaitForProcessesToExit( +BASE_EXPORT bool WaitForProcessesToExit( const FilePath::StringType& executable_name, int64 wait_milliseconds, const ProcessFilter* filter); @@ -415,8 +418,8 @@ BASE_API bool WaitForProcessesToExit( // Wait for a single process to exit. Return true if it exited cleanly within // the given time limit. On Linux |handle| must be a child process, however // on Mac and Windows it can be any process. -BASE_API bool WaitForSingleProcess(ProcessHandle handle, - int64 wait_milliseconds); +BASE_EXPORT bool WaitForSingleProcess(ProcessHandle handle, + int64 wait_milliseconds); // Waits a certain amount of time (can be 0) for all the processes with a given // executable name to exit, then kills off any of them that are still around. @@ -424,16 +427,16 @@ BASE_API bool WaitForSingleProcess(ProcessHandle handle, // on. Killed processes are ended with the given exit code. Returns false if // any processes needed to be killed, true if they all exited cleanly within // the wait_milliseconds delay. -BASE_API bool CleanupProcesses(const FilePath::StringType& executable_name, - int64 wait_milliseconds, - int exit_code, - const ProcessFilter* filter); +BASE_EXPORT bool CleanupProcesses(const FilePath::StringType& executable_name, + int64 wait_milliseconds, + int exit_code, + const ProcessFilter* filter); // This class provides a way to iterate through a list of processes on the // current machine with a specified filter. // To use, create an instance and then call NextProcessEntry() until it returns // false. -class BASE_API ProcessIterator { +class BASE_EXPORT ProcessIterator { public: typedef std::list<ProcessEntry> ProcessEntries; @@ -483,7 +486,7 @@ class BASE_API ProcessIterator { // on the current machine that were started from the given executable // name. To use, create an instance and then call NextProcessEntry() // until it returns false. -class BASE_API NamedProcessIterator : public ProcessIterator { +class BASE_EXPORT NamedProcessIterator : public ProcessIterator { public: NamedProcessIterator(const FilePath::StringType& executable_name, const ProcessFilter* filter); @@ -548,13 +551,13 @@ struct FreeMBytes { }; // Convert a POSIX timeval to microseconds. -BASE_API int64 TimeValToMicroseconds(const struct timeval& tv); +BASE_EXPORT int64 TimeValToMicroseconds(const struct timeval& tv); // Provides performance metrics for a specified process (CPU usage, memory and // IO counters). To use it, invoke CreateProcessMetrics() to get an instance // for a specific process, then access the information with the different get // methods. -class BASE_API ProcessMetrics { +class BASE_EXPORT ProcessMetrics { public: ~ProcessMetrics(); @@ -656,13 +659,14 @@ class BASE_API ProcessMetrics { #if defined(OS_LINUX) // Retrieves data from /proc/meminfo about system-wide memory consumption. // Values are in KB. Returns true on success. -BASE_API bool GetSystemMemoryInfo(int* total_kb, int* free_kb, int* buffers_kb, - int* cache_kb, int* shmem_kb); +BASE_EXPORT bool GetSystemMemoryInfo(int* total_kb, int* free_kb, + int* buffers_kb, int* cache_kb, + int* shmem_kb); #endif // Returns the memory committed by the system in KBytes. // Returns 0 if it can't compute the commit charge. -BASE_API size_t GetSystemCommitCharge(); +BASE_EXPORT size_t GetSystemCommitCharge(); // Enables low fragmentation heap (LFH) for every heaps of this process. This // won't have any effect on heaps created after this function call. It will not @@ -670,30 +674,30 @@ BASE_API size_t GetSystemCommitCharge(); // better to call this function early in initialization and again before // entering the main loop. // Note: Returns true on Windows 2000 without doing anything. -BASE_API bool EnableLowFragmentationHeap(); +BASE_EXPORT bool EnableLowFragmentationHeap(); // Enables 'terminate on heap corruption' flag. Helps protect against heap // overflow. Has no effect if the OS doesn't provide the necessary facility. -BASE_API void EnableTerminationOnHeapCorruption(); +BASE_EXPORT void EnableTerminationOnHeapCorruption(); #if !defined(OS_WIN) // Turns on process termination if memory runs out. This is handled on Windows // inside RegisterInvalidParamHandler(). -BASE_API void EnableTerminationOnOutOfMemory(); +BASE_EXPORT void EnableTerminationOnOutOfMemory(); #if defined(OS_MACOSX) // Exposed for testing. -BASE_API malloc_zone_t* GetPurgeableZone(); +BASE_EXPORT malloc_zone_t* GetPurgeableZone(); #endif #endif // Enables stack dump to console output on exception and signals. // When enabled, the process will quit immediately. This is meant to be used in // unit_tests only! -BASE_API bool EnableInProcessStackDumping(); +BASE_EXPORT bool EnableInProcessStackDumping(); // If supported on the platform, and the user has sufficent rights, increase // the current process's scheduling priority to a high priority. -BASE_API void RaiseProcessToHighPriority(); +BASE_EXPORT void RaiseProcessToHighPriority(); #if defined(OS_MACOSX) // Restore the default exception handler, setting it to Apple Crash Reporter diff --git a/base/rand_util.h b/base/rand_util.h index 6bfbcb4..c98cb45 100644 --- a/base/rand_util.h +++ b/base/rand_util.h @@ -8,40 +8,40 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { // Returns a random number in range [0, kuint64max]. Thread-safe. -BASE_API uint64 RandUint64(); +BASE_EXPORT uint64 RandUint64(); // Returns a random number between min and max (inclusive). Thread-safe. -BASE_API int RandInt(int min, int max); +BASE_EXPORT int RandInt(int min, int max); // Returns a random number in range [0, max). Thread-safe. // // Note that this can be used as an adapter for std::random_shuffle(): // Given a pre-populated |std::vector<int> myvector|, shuffle it as // std::random_shuffle(myvector.begin(), myvector.end(), base::RandGenerator); -BASE_API uint64 RandGenerator(uint64 max); +BASE_EXPORT uint64 RandGenerator(uint64 max); // Returns a random double in range [0, 1). Thread-safe. -BASE_API double RandDouble(); +BASE_EXPORT double RandDouble(); // Given input |bits|, convert with maximum precision to a double in // the range [0, 1). Thread-safe. -BASE_API double BitsToOpenEndedUnitInterval(uint64 bits); +BASE_EXPORT double BitsToOpenEndedUnitInterval(uint64 bits); // Fills |output_length| bytes of |output| with cryptographically strong random // data. -BASE_API void RandBytes(void* output, size_t output_length); +BASE_EXPORT void RandBytes(void* output, size_t output_length); // Fills a string of length |length| with with cryptographically strong random // data and returns it. // // Not that this is a variation of |RandBytes| with a different return type. -BASE_API std::string RandBytesAsString(size_t length); +BASE_EXPORT std::string RandBytesAsString(size_t length); } // namespace base diff --git a/base/rand_util_c.h b/base/rand_util_c.h index 8320ba6..f16d264 100644 --- a/base/rand_util_c.h +++ b/base/rand_util_c.h @@ -6,7 +6,7 @@ #define BASE_RAND_UTIL_C_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #ifdef __cplusplus extern "C" { @@ -17,7 +17,7 @@ extern "C" { // Returns an FD for /dev/urandom, possibly pre-opened before sandboxing // was switched on. This is a C function so that Native Client can use it. -BASE_API int GetUrandomFD(void); +BASE_EXPORT int GetUrandomFD(void); #ifdef __cplusplus } diff --git a/base/resource_util.h b/base/resource_util.h index c867abc..26d15cf 100644 --- a/base/resource_util.h +++ b/base/resource_util.h @@ -11,7 +11,7 @@ #include <windows.h> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -19,8 +19,9 @@ namespace base { // Function for getting a data resource (BINDATA) from a dll. Some // resources are optional, especially in unit tests, so this returns false // but doesn't raise an error if the resource can't be loaded. -bool BASE_API GetDataResourceFromModule(HMODULE module, int resource_id, - void** data, size_t* length); +bool BASE_EXPORT GetDataResourceFromModule(HMODULE module, int resource_id, + void** data, size_t* length); + } // namespace base #endif // BASE_RESOURCE_UTIL_H__ diff --git a/base/safe_strerror_posix.h b/base/safe_strerror_posix.h index e72c836..60fdec3 100644 --- a/base/safe_strerror_posix.h +++ b/base/safe_strerror_posix.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" // BEFORE using anything from this file, first look at PLOG and friends in // logging.h and use them instead if applicable. @@ -26,7 +26,7 @@ // result is always null-terminated. The value of errno is never changed. // // Use this instead of strerror_r(). -BASE_API void safe_strerror_r(int err, char *buf, size_t len); +BASE_EXPORT void safe_strerror_r(int err, char *buf, size_t len); // Calls safe_strerror_r with a buffer of suitable size and returns the result // in a C++ string. @@ -34,6 +34,6 @@ BASE_API void safe_strerror_r(int err, char *buf, size_t len); // Use this instead of strerror(). Note though that safe_strerror_r will be // more robust in the case of heap corruption errors, since it doesn't need to // allocate a string. -BASE_API std::string safe_strerror(int err); +BASE_EXPORT std::string safe_strerror(int err); #endif // BASE_SAFE_STRERROR_POSIX_H_ diff --git a/base/scoped_native_library.h b/base/scoped_native_library.h index 4be66ed..65a45a4 100644 --- a/base/scoped_native_library.h +++ b/base/scoped_native_library.h @@ -6,7 +6,7 @@ #define BASE_SCOPED_NATIVE_LIBRARY_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/native_library.h" class FilePath; @@ -16,7 +16,7 @@ namespace base { // A class which encapsulates a base::NativeLibrary object available only in a // scope. // This class automatically unloads the loaded library in its destructor. -class BASE_API ScopedNativeLibrary { +class BASE_EXPORT ScopedNativeLibrary { public: // Initializes with a NULL library. ScopedNativeLibrary(); diff --git a/base/scoped_temp_dir.h b/base/scoped_temp_dir.h index d9f0e2f..a549c30 100644 --- a/base/scoped_temp_dir.h +++ b/base/scoped_temp_dir.h @@ -16,10 +16,10 @@ // (CreateUniqueTempDir, CreateUniqueTempDirUnderPath, and Set) must have // intervening calls to Delete or Take, or the calls will fail. -#include "base/base_api.h" +#include "base/base_export.h" #include "base/file_path.h" -class BASE_API ScopedTempDir { +class BASE_EXPORT ScopedTempDir { public: // No directory is owned/created initially. ScopedTempDir(); diff --git a/base/sha1.h b/base/sha1.h index 7625189..779a190 100644 --- a/base/sha1.h +++ b/base/sha1.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" namespace base { @@ -20,12 +20,12 @@ enum { // Computes the SHA-1 hash of the input string |str| and returns the full // hash. -BASE_API std::string SHA1HashString(const std::string& str); +BASE_EXPORT std::string SHA1HashString(const std::string& str); // Computes the SHA-1 hash of the |len| bytes in |data| and puts the hash // in |hash|. |hash| must be SHA1_LENGTH bytes long. -BASE_API void SHA1HashBytes(const unsigned char* data, size_t len, - unsigned char* hash); +BASE_EXPORT void SHA1HashBytes(const unsigned char* data, size_t len, + unsigned char* hash); } // namespace base diff --git a/base/shared_memory.h b/base/shared_memory.h index cf07da3..c9dfd6e 100644 --- a/base/shared_memory.h +++ b/base/shared_memory.h @@ -15,7 +15,7 @@ #endif #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/process.h" @@ -40,7 +40,7 @@ typedef ino_t SharedMemoryId; // Platform abstraction for shared memory. Provides a C++ wrapper // around the OS primitive for a memory mapped file. -class BASE_API SharedMemory { +class BASE_EXPORT SharedMemory { public: SharedMemory(); diff --git a/base/string16.h b/base/string16.h index 16ba86e..4c7b21f 100644 --- a/base/string16.h +++ b/base/string16.h @@ -30,7 +30,7 @@ #include <stdio.h> #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #if defined(WCHAR_T_IS_UTF16) @@ -47,12 +47,12 @@ namespace base { // char16 versions of the functions required by string16_char_traits; these // are based on the wide character functions of similar names ("w" or "wcs" // instead of "c16"). -BASE_API int c16memcmp(const char16* s1, const char16* s2, size_t n); -BASE_API size_t c16len(const char16* s); -BASE_API const char16* c16memchr(const char16* s, char16 c, size_t n); -BASE_API char16* c16memmove(char16* s1, const char16* s2, size_t n); -BASE_API char16* c16memcpy(char16* s1, const char16* s2, size_t n); -BASE_API char16* c16memset(char16* s, char16 c, size_t n); +BASE_EXPORT int c16memcmp(const char16* s1, const char16* s2, size_t n); +BASE_EXPORT size_t c16len(const char16* s); +BASE_EXPORT const char16* c16memchr(const char16* s, char16 c, size_t n); +BASE_EXPORT char16* c16memmove(char16* s1, const char16* s2, size_t n); +BASE_EXPORT char16* c16memcpy(char16* s1, const char16* s2, size_t n); +BASE_EXPORT char16* c16memset(char16* s, char16 c, size_t n); struct string16_char_traits { typedef char16 char_type; @@ -169,8 +169,8 @@ extern template class std::basic_string<char16, base::string16_char_traits>; typedef std::basic_string<char16, base::string16_char_traits> string16; namespace base { -BASE_API extern std::ostream& operator<<(std::ostream& out, - const string16& str); +BASE_EXPORT extern std::ostream& operator<<(std::ostream& out, + const string16& str); } #endif // WCHAR_T_IS_UTF32 diff --git a/base/string_number_conversions.h b/base/string_number_conversions.h index a4b6e3e..6cf6a76 100644 --- a/base/string_number_conversions.h +++ b/base/string_number_conversions.h @@ -8,7 +8,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/string16.h" @@ -28,21 +28,21 @@ namespace base { // Number -> string conversions ------------------------------------------------ -BASE_API std::string IntToString(int value); -BASE_API string16 IntToString16(int value); +BASE_EXPORT std::string IntToString(int value); +BASE_EXPORT string16 IntToString16(int value); -BASE_API std::string UintToString(unsigned value); -BASE_API string16 UintToString16(unsigned value); +BASE_EXPORT std::string UintToString(unsigned value); +BASE_EXPORT string16 UintToString16(unsigned value); -BASE_API std::string Int64ToString(int64 value); -BASE_API string16 Int64ToString16(int64 value); +BASE_EXPORT std::string Int64ToString(int64 value); +BASE_EXPORT string16 Int64ToString16(int64 value); -BASE_API std::string Uint64ToString(uint64 value); -BASE_API string16 Uint64ToString16(uint64 value); +BASE_EXPORT std::string Uint64ToString(uint64 value); +BASE_EXPORT string16 Uint64ToString16(uint64 value); // DoubleToString converts the double to a string format that ignores the // locale. If you want to use locale specific formatting, use ICU. -BASE_API std::string DoubleToString(double value); +BASE_EXPORT std::string DoubleToString(double value); // String -> number conversions ------------------------------------------------ @@ -58,30 +58,32 @@ BASE_API std::string DoubleToString(double value); // - No characters parseable as a number at the beginning of the string. // |*output| will be set to 0. // - Empty string. |*output| will be set to 0. -BASE_API bool StringToInt(const std::string& input, int* output); -BASE_API bool StringToInt(std::string::const_iterator begin, - std::string::const_iterator end, - int* output); -BASE_API bool StringToInt(const char* begin, const char* end, int* output); - -BASE_API bool StringToInt(const string16& input, int* output); -BASE_API bool StringToInt(string16::const_iterator begin, - string16::const_iterator end, - int* output); -BASE_API bool StringToInt(const char16* begin, const char16* end, int* output); - -BASE_API bool StringToInt64(const std::string& input, int64* output); -BASE_API bool StringToInt64(std::string::const_iterator begin, - std::string::const_iterator end, - int64* output); -BASE_API bool StringToInt64(const char* begin, const char* end, int64* output); - -BASE_API bool StringToInt64(const string16& input, int64* output); -BASE_API bool StringToInt64(string16::const_iterator begin, - string16::const_iterator end, - int64* output); -BASE_API bool StringToInt64(const char16* begin, const char16* end, - int64* output); +BASE_EXPORT bool StringToInt(const std::string& input, int* output); +BASE_EXPORT bool StringToInt(std::string::const_iterator begin, + std::string::const_iterator end, + int* output); +BASE_EXPORT bool StringToInt(const char* begin, const char* end, int* output); + +BASE_EXPORT bool StringToInt(const string16& input, int* output); +BASE_EXPORT bool StringToInt(string16::const_iterator begin, + string16::const_iterator end, + int* output); +BASE_EXPORT bool StringToInt(const char16* begin, const char16* end, + int* output); + +BASE_EXPORT bool StringToInt64(const std::string& input, int64* output); +BASE_EXPORT bool StringToInt64(std::string::const_iterator begin, + std::string::const_iterator end, + int64* output); +BASE_EXPORT bool StringToInt64(const char* begin, const char* end, + int64* output); + +BASE_EXPORT bool StringToInt64(const string16& input, int64* output); +BASE_EXPORT bool StringToInt64(string16::const_iterator begin, + string16::const_iterator end, + int64* output); +BASE_EXPORT bool StringToInt64(const char16* begin, const char16* end, + int64* output); // For floating-point conversions, only conversions of input strings in decimal // form are defined to work. Behavior with strings representing floating-point @@ -89,7 +91,7 @@ BASE_API bool StringToInt64(const char16* begin, const char16* end, // NaN and inf) is undefined. Otherwise, these behave the same as the integral // variants. This expects the input string to NOT be specific to the locale. // If your input is locale specific, use ICU to read the number. -BASE_API bool StringToDouble(const std::string& input, double* output); +BASE_EXPORT bool StringToDouble(const std::string& input, double* output); // Hex encoding ---------------------------------------------------------------- @@ -99,21 +101,22 @@ BASE_API bool StringToDouble(const std::string& input, double* output); // you suspect that the data you want to format might be large, the absolute // max size for |size| should be is // std::numeric_limits<size_t>::max() / 2 -BASE_API std::string HexEncode(const void* bytes, size_t size); +BASE_EXPORT std::string HexEncode(const void* bytes, size_t size); // Best effort conversion, see StringToInt above for restrictions. -BASE_API bool HexStringToInt(const std::string& input, int* output); -BASE_API bool HexStringToInt(std::string::const_iterator begin, - std::string::const_iterator end, - int* output); -BASE_API bool HexStringToInt(const char* begin, const char* end, int* output); +BASE_EXPORT bool HexStringToInt(const std::string& input, int* output); +BASE_EXPORT bool HexStringToInt(std::string::const_iterator begin, + std::string::const_iterator end, + int* output); +BASE_EXPORT bool HexStringToInt(const char* begin, const char* end, + int* output); // Similar to the previous functions, except that output is a vector of bytes. // |*output| will contain as many bytes as were successfully parsed prior to the // error. There is no overflow, but input.size() must be evenly divisible by 2. // Leading 0x or +/- are not allowed. -BASE_API bool HexStringToBytes(const std::string& input, - std::vector<uint8>* output); +BASE_EXPORT bool HexStringToBytes(const std::string& input, + std::vector<uint8>* output); } // namespace base diff --git a/base/string_piece.h b/base/string_piece.h index 60380b1..1077ac1 100644 --- a/base/string_piece.h +++ b/base/string_piece.h @@ -21,12 +21,12 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { -class BASE_API StringPiece { +class BASE_EXPORT StringPiece { public: // standard STL container boilerplate typedef size_t size_type; @@ -164,7 +164,7 @@ class BASE_API StringPiece { size_type length_; }; -BASE_API bool operator==(const StringPiece& x, const StringPiece& y); +BASE_EXPORT bool operator==(const StringPiece& x, const StringPiece& y); inline bool operator!=(const StringPiece& x, const StringPiece& y) { return !(x == y); diff --git a/base/string_split.h b/base/string_split.h index 883b126..eb0c219 100644 --- a/base/string_split.h +++ b/base/string_split.h @@ -10,7 +10,7 @@ #include <utility> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string16.h" namespace base { @@ -21,48 +21,48 @@ namespace base { // // Every substring is trimmed of any leading or trailing white space. // NOTE: |c| must be in BMP (Basic Multilingual Plane) -BASE_API void SplitString(const string16& str, - char16 c, - std::vector<string16>* r); +BASE_EXPORT void SplitString(const string16& str, + char16 c, + std::vector<string16>* r); // |str| should not be in a multi-byte encoding like Shift-JIS or GBK in which // the trailing byte of a multi-byte character can be in the ASCII range. // UTF-8, and other single/multi-byte ASCII-compatible encodings are OK. // Note: |c| must be in the ASCII range. -BASE_API void SplitString(const std::string& str, - char c, - std::vector<std::string>* r); +BASE_EXPORT void SplitString(const std::string& str, + char c, + std::vector<std::string>* r); -BASE_API bool SplitStringIntoKeyValues( +BASE_EXPORT bool SplitStringIntoKeyValues( const std::string& line, char key_value_delimiter, std::string* key, std::vector<std::string>* values); -BASE_API bool SplitStringIntoKeyValuePairs( +BASE_EXPORT bool SplitStringIntoKeyValuePairs( const std::string& line, char key_value_delimiter, char key_value_pair_delimiter, std::vector<std::pair<std::string, std::string> >* kv_pairs); // The same as SplitString, but use a substring delimiter instead of a char. -BASE_API void SplitStringUsingSubstr(const string16& str, - const string16& s, - std::vector<string16>* r); -BASE_API void SplitStringUsingSubstr(const std::string& str, - const std::string& s, - std::vector<std::string>* r); +BASE_EXPORT void SplitStringUsingSubstr(const string16& str, + const string16& s, + std::vector<string16>* r); +BASE_EXPORT void SplitStringUsingSubstr(const std::string& str, + const std::string& s, + std::vector<std::string>* r); // The same as SplitString, but don't trim white space. // NOTE: |c| must be in BMP (Basic Multilingual Plane) -BASE_API void SplitStringDontTrim(const string16& str, - char16 c, - std::vector<string16>* r); +BASE_EXPORT void SplitStringDontTrim(const string16& str, + char16 c, + std::vector<string16>* r); // |str| should not be in a multi-byte encoding like Shift-JIS or GBK in which // the trailing byte of a multi-byte character can be in the ASCII range. // UTF-8, and other single/multi-byte ASCII-compatible encodings are OK. // Note: |c| must be in the ASCII range. -BASE_API void SplitStringDontTrim(const std::string& str, - char c, - std::vector<std::string>* r); +BASE_EXPORT void SplitStringDontTrim(const std::string& str, + char c, + std::vector<std::string>* r); // WARNING: this uses whitespace as defined by the HTML5 spec. If you need // a function similar to this but want to trim all types of whitespace, then @@ -72,12 +72,12 @@ BASE_API void SplitStringDontTrim(const std::string& str, // Splits the string along whitespace (where whitespace is the five space // characters defined by HTML 5). Each contiguous block of non-whitespace // characters is added to result. -BASE_API void SplitStringAlongWhitespace(const std::wstring& str, - std::vector<std::wstring>* result); -BASE_API void SplitStringAlongWhitespace(const string16& str, - std::vector<string16>* result); -BASE_API void SplitStringAlongWhitespace(const std::string& str, - std::vector<std::string>* result); +BASE_EXPORT void SplitStringAlongWhitespace(const std::wstring& str, + std::vector<std::wstring>* result); +BASE_EXPORT void SplitStringAlongWhitespace(const string16& str, + std::vector<string16>* result); +BASE_EXPORT void SplitStringAlongWhitespace(const std::string& str, + std::vector<std::string>* result); } // namespace base diff --git a/base/string_util.h b/base/string_util.h index 3f695a8..aa5966e 100644 --- a/base/string_util.h +++ b/base/string_util.h @@ -14,7 +14,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/compiler_specific.h" #include "base/string16.h" @@ -93,8 +93,8 @@ inline int swprintf(wchar_t* buffer, size_t size, const wchar_t* format, ...) { // long as |dst_size| is not 0. Returns the length of |src| in characters. // If the return value is >= dst_size, then the output was truncated. // NOTE: All sizes are in number of characters, NOT in bytes. -BASE_API size_t strlcpy(char* dst, const char* src, size_t dst_size); -BASE_API size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size); +BASE_EXPORT size_t strlcpy(char* dst, const char* src, size_t dst_size); +BASE_EXPORT size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size); // Scan a wprintf format string to determine whether it's portable across a // variety of systems. This function only checks that the conversion @@ -117,7 +117,7 @@ BASE_API size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size); // working with wprintf. // // This function is intended to be called from base::vswprintf. -BASE_API bool IsWprintfFormatPortable(const wchar_t* format); +BASE_EXPORT bool IsWprintfFormatPortable(const wchar_t* format); // ASCII-specific tolower. The standard library's tolower is locale sensitive, // so we don't want to use it here. @@ -168,43 +168,43 @@ template<typename Char> struct CaseInsensitiveCompareASCII { // have an empty string to use (e.g. in an error case). These should not be // used as initializers, function arguments, or return values for functions // which return by value or outparam. -BASE_API const std::string& EmptyString(); -BASE_API const std::wstring& EmptyWString(); -BASE_API const string16& EmptyString16(); +BASE_EXPORT const std::string& EmptyString(); +BASE_EXPORT const std::wstring& EmptyWString(); +BASE_EXPORT const string16& EmptyString16(); -BASE_API extern const wchar_t kWhitespaceWide[]; -BASE_API extern const char16 kWhitespaceUTF16[]; -BASE_API extern const char kWhitespaceASCII[]; +BASE_EXPORT extern const wchar_t kWhitespaceWide[]; +BASE_EXPORT extern const char16 kWhitespaceUTF16[]; +BASE_EXPORT extern const char kWhitespaceASCII[]; -BASE_API extern const char kUtf8ByteOrderMark[]; +BASE_EXPORT extern const char kUtf8ByteOrderMark[]; // Removes characters in remove_chars from anywhere in input. Returns true if // any characters were removed. // NOTE: Safe to use the same variable for both input and output. -BASE_API bool RemoveChars(const string16& input, - const char16 remove_chars[], - string16* output); -BASE_API bool RemoveChars(const std::string& input, - const char remove_chars[], - std::string* output); +BASE_EXPORT bool RemoveChars(const string16& input, + const char16 remove_chars[], + string16* output); +BASE_EXPORT bool RemoveChars(const std::string& input, + const char remove_chars[], + std::string* output); // Removes characters in trim_chars from the beginning and end of input. // NOTE: Safe to use the same variable for both input and output. -BASE_API bool TrimString(const std::wstring& input, - const wchar_t trim_chars[], - std::wstring* output); -BASE_API bool TrimString(const string16& input, - const char16 trim_chars[], - string16* output); -BASE_API bool TrimString(const std::string& input, - const char trim_chars[], - std::string* output); +BASE_EXPORT bool TrimString(const std::wstring& input, + const wchar_t trim_chars[], + std::wstring* output); +BASE_EXPORT bool TrimString(const string16& input, + const char16 trim_chars[], + string16* output); +BASE_EXPORT bool TrimString(const std::string& input, + const char trim_chars[], + std::string* output); // Truncates a string to the nearest UTF-8 character that will leave // the string less than or equal to the specified byte size. -BASE_API void TruncateUTF8ToByteSize(const std::string& input, - const size_t byte_size, - std::string* output); +BASE_EXPORT void TruncateUTF8ToByteSize(const std::string& input, + const size_t byte_size, + std::string* output); // Trims any whitespace from either end of the input string. Returns where // whitespace was found. @@ -219,18 +219,18 @@ enum TrimPositions { TRIM_TRAILING = 1 << 1, TRIM_ALL = TRIM_LEADING | TRIM_TRAILING, }; -BASE_API TrimPositions TrimWhitespace(const string16& input, - TrimPositions positions, - string16* output); -BASE_API TrimPositions TrimWhitespaceASCII(const std::string& input, - TrimPositions positions, - std::string* output); +BASE_EXPORT TrimPositions TrimWhitespace(const string16& input, + TrimPositions positions, + string16* output); +BASE_EXPORT TrimPositions TrimWhitespaceASCII(const std::string& input, + TrimPositions positions, + std::string* output); // Deprecated. This function is only for backward compatibility and calls // TrimWhitespaceASCII(). -BASE_API TrimPositions TrimWhitespace(const std::string& input, - TrimPositions positions, - std::string* output); +BASE_EXPORT TrimPositions TrimWhitespace(const std::string& input, + TrimPositions positions, + std::string* output); // Searches for CR or LF characters. Removes all contiguous whitespace // strings that contain them. This is useful when trying to deal with text @@ -240,35 +240,38 @@ BASE_API TrimPositions TrimWhitespace(const std::string& input, // (2) If |trim_sequences_with_line_breaks| is true, any other whitespace // sequences containing a CR or LF are trimmed. // (3) All other whitespace sequences are converted to single spaces. -BASE_API std::wstring CollapseWhitespace(const std::wstring& text, - bool trim_sequences_with_line_breaks); -BASE_API string16 CollapseWhitespace(const string16& text, - bool trim_sequences_with_line_breaks); -BASE_API std::string CollapseWhitespaceASCII( - const std::string& text, bool trim_sequences_with_line_breaks); +BASE_EXPORT std::wstring CollapseWhitespace( + const std::wstring& text, + bool trim_sequences_with_line_breaks); +BASE_EXPORT string16 CollapseWhitespace( + const string16& text, + bool trim_sequences_with_line_breaks); +BASE_EXPORT std::string CollapseWhitespaceASCII( + const std::string& text, + bool trim_sequences_with_line_breaks); // Returns true if the passed string is empty or contains only white-space // characters. -BASE_API bool ContainsOnlyWhitespaceASCII(const std::string& str); -BASE_API bool ContainsOnlyWhitespace(const string16& str); +BASE_EXPORT bool ContainsOnlyWhitespaceASCII(const std::string& str); +BASE_EXPORT bool ContainsOnlyWhitespace(const string16& str); // Returns true if |input| is empty or contains only characters found in // |characters|. -BASE_API bool ContainsOnlyChars(const std::wstring& input, - const std::wstring& characters); -BASE_API bool ContainsOnlyChars(const string16& input, - const string16& characters); -BASE_API bool ContainsOnlyChars(const std::string& input, - const std::string& characters); +BASE_EXPORT bool ContainsOnlyChars(const std::wstring& input, + const std::wstring& characters); +BASE_EXPORT bool ContainsOnlyChars(const string16& input, + const string16& characters); +BASE_EXPORT bool ContainsOnlyChars(const std::string& input, + const std::string& characters); // Converts to 7-bit ASCII by truncating. The result must be known to be ASCII // beforehand. -BASE_API std::string WideToASCII(const std::wstring& wide); -BASE_API std::string UTF16ToASCII(const string16& utf16); +BASE_EXPORT std::string WideToASCII(const std::wstring& wide); +BASE_EXPORT std::string UTF16ToASCII(const string16& utf16); // Converts the given wide string to the corresponding Latin1. This will fail // (return false) if any characters are more than 255. -BASE_API bool WideToLatin1(const std::wstring& wide, std::string* latin1); +BASE_EXPORT bool WideToLatin1(const std::wstring& wide, std::string* latin1); // Returns true if the specified string matches the criteria. How can a wide // string be 8-bit or UTF8? It contains only characters that are < 256 (in the @@ -281,10 +284,10 @@ BASE_API bool WideToLatin1(const std::wstring& wide, std::string* latin1); // to have the maximum 'discriminating' power from other encodings. If // there's a use case for just checking the structural validity, we have to // add a new function for that. -BASE_API bool IsStringUTF8(const std::string& str); -BASE_API bool IsStringASCII(const std::wstring& str); -BASE_API bool IsStringASCII(const base::StringPiece& str); -BASE_API bool IsStringASCII(const string16& str); +BASE_EXPORT bool IsStringUTF8(const std::string& str); +BASE_EXPORT bool IsStringASCII(const std::wstring& str); +BASE_EXPORT bool IsStringASCII(const base::StringPiece& str); +BASE_EXPORT bool IsStringASCII(const string16& str); // Converts the elements of the given string. This version uses a pointer to // clearly differentiate it from the non-pointer variant. @@ -318,55 +321,55 @@ template <class str> inline str StringToUpperASCII(const str& s) { // string. This is useful for doing checking if an input string matches some // token, and it is optimized to avoid intermediate string copies. This API is // borrowed from the equivalent APIs in Mozilla. -BASE_API bool LowerCaseEqualsASCII(const std::string& a, const char* b); -BASE_API bool LowerCaseEqualsASCII(const std::wstring& a, const char* b); -BASE_API bool LowerCaseEqualsASCII(const string16& a, const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(const std::string& a, const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(const std::wstring& a, const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(const string16& a, const char* b); // Same thing, but with string iterators instead. -BASE_API bool LowerCaseEqualsASCII(std::string::const_iterator a_begin, - std::string::const_iterator a_end, - const char* b); -BASE_API bool LowerCaseEqualsASCII(std::wstring::const_iterator a_begin, - std::wstring::const_iterator a_end, - const char* b); -BASE_API bool LowerCaseEqualsASCII(string16::const_iterator a_begin, - string16::const_iterator a_end, - const char* b); -BASE_API bool LowerCaseEqualsASCII(const char* a_begin, - const char* a_end, - const char* b); -BASE_API bool LowerCaseEqualsASCII(const wchar_t* a_begin, - const wchar_t* a_end, - const char* b); -BASE_API bool LowerCaseEqualsASCII(const char16* a_begin, - const char16* a_end, - const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(std::string::const_iterator a_begin, + std::string::const_iterator a_end, + const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(std::wstring::const_iterator a_begin, + std::wstring::const_iterator a_end, + const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(string16::const_iterator a_begin, + string16::const_iterator a_end, + const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(const char* a_begin, + const char* a_end, + const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(const wchar_t* a_begin, + const wchar_t* a_end, + const char* b); +BASE_EXPORT bool LowerCaseEqualsASCII(const char16* a_begin, + const char16* a_end, + const char* b); // Performs a case-sensitive string compare. The behavior is undefined if both // strings are not ASCII. -BASE_API bool EqualsASCII(const string16& a, const base::StringPiece& b); +BASE_EXPORT bool EqualsASCII(const string16& a, const base::StringPiece& b); // Returns true if str starts with search, or false otherwise. -BASE_API bool StartsWithASCII(const std::string& str, - const std::string& search, - bool case_sensitive); -BASE_API bool StartsWith(const std::wstring& str, - const std::wstring& search, - bool case_sensitive); -BASE_API bool StartsWith(const string16& str, - const string16& search, - bool case_sensitive); +BASE_EXPORT bool StartsWithASCII(const std::string& str, + const std::string& search, + bool case_sensitive); +BASE_EXPORT bool StartsWith(const std::wstring& str, + const std::wstring& search, + bool case_sensitive); +BASE_EXPORT bool StartsWith(const string16& str, + const string16& search, + bool case_sensitive); // Returns true if str ends with search, or false otherwise. -BASE_API bool EndsWith(const std::string& str, - const std::string& search, - bool case_sensitive); -BASE_API bool EndsWith(const std::wstring& str, - const std::wstring& search, - bool case_sensitive); -BASE_API bool EndsWith(const string16& str, - const string16& search, - bool case_sensitive); +BASE_EXPORT bool EndsWith(const std::string& str, + const std::string& search, + bool case_sensitive); +BASE_EXPORT bool EndsWith(const std::wstring& str, + const std::wstring& search, + bool case_sensitive); +BASE_EXPORT bool EndsWith(const string16& str, + const string16& search, + bool case_sensitive); // Determines the type of ASCII character, independent of locale (the C @@ -412,15 +415,16 @@ inline bool IsWhitespace(wchar_t c) { // appropriate for use in any UI; use of FormatBytes and friends in ui/base is // highly recommended instead. TODO(avi): Figure out how to get callers to use // FormatBytes instead; remove this. -BASE_API string16 FormatBytesUnlocalized(int64 bytes); +BASE_EXPORT string16 FormatBytesUnlocalized(int64 bytes); // Starting at |start_offset| (usually 0), replace the first instance of // |find_this| with |replace_with|. -BASE_API void ReplaceFirstSubstringAfterOffset(string16* str, - string16::size_type start_offset, - const string16& find_this, - const string16& replace_with); -BASE_API void ReplaceFirstSubstringAfterOffset( +BASE_EXPORT void ReplaceFirstSubstringAfterOffset( + string16* str, + string16::size_type start_offset, + const string16& find_this, + const string16& replace_with); +BASE_EXPORT void ReplaceFirstSubstringAfterOffset( std::string* str, std::string::size_type start_offset, const std::string& find_this, @@ -432,14 +436,16 @@ BASE_API void ReplaceFirstSubstringAfterOffset( // This does entire substrings; use std::replace in <algorithm> for single // characters, for example: // std::replace(str.begin(), str.end(), 'a', 'b'); -BASE_API void ReplaceSubstringsAfterOffset(string16* str, - string16::size_type start_offset, - const string16& find_this, - const string16& replace_with); -BASE_API void ReplaceSubstringsAfterOffset(std::string* str, - std::string::size_type start_offset, - const std::string& find_this, - const std::string& replace_with); +BASE_EXPORT void ReplaceSubstringsAfterOffset( + string16* str, + string16::size_type start_offset, + const string16& find_this, + const string16& replace_with); +BASE_EXPORT void ReplaceSubstringsAfterOffset( + std::string* str, + std::string::size_type start_offset, + const std::string& find_this, + const std::string& replace_with); // This is mpcomplete's pattern for saving a string copy when dealing with // a function that writes results into a wchar_t[] and wanting the result to @@ -469,49 +475,51 @@ inline typename string_type::value_type* WriteInto(string_type* str, // Splits a string into its fields delimited by any of the characters in // |delimiters|. Each field is added to the |tokens| vector. Returns the // number of tokens found. -BASE_API size_t Tokenize(const std::wstring& str, - const std::wstring& delimiters, - std::vector<std::wstring>* tokens); -BASE_API size_t Tokenize(const string16& str, - const string16& delimiters, - std::vector<string16>* tokens); -BASE_API size_t Tokenize(const std::string& str, - const std::string& delimiters, - std::vector<std::string>* tokens); -BASE_API size_t Tokenize(const base::StringPiece& str, - const base::StringPiece& delimiters, - std::vector<base::StringPiece>* tokens); +BASE_EXPORT size_t Tokenize(const std::wstring& str, + const std::wstring& delimiters, + std::vector<std::wstring>* tokens); +BASE_EXPORT size_t Tokenize(const string16& str, + const string16& delimiters, + std::vector<string16>* tokens); +BASE_EXPORT size_t Tokenize(const std::string& str, + const std::string& delimiters, + std::vector<std::string>* tokens); +BASE_EXPORT size_t Tokenize(const base::StringPiece& str, + const base::StringPiece& delimiters, + std::vector<base::StringPiece>* tokens); // Does the opposite of SplitString(). -BASE_API string16 JoinString(const std::vector<string16>& parts, char16 s); -BASE_API std::string JoinString(const std::vector<std::string>& parts, char s); +BASE_EXPORT string16 JoinString(const std::vector<string16>& parts, char16 s); +BASE_EXPORT std::string JoinString( + const std::vector<std::string>& parts, char s); // Replace $1-$2-$3..$9 in the format string with |a|-|b|-|c|..|i| respectively. // Additionally, any number of consecutive '$' characters is replaced by that // number less one. Eg $$->$, $$$->$$, etc. The offsets parameter here can be // NULL. This only allows you to use up to nine replacements. -BASE_API string16 ReplaceStringPlaceholders(const string16& format_string, - const std::vector<string16>& subst, - std::vector<size_t>* offsets); +BASE_EXPORT string16 ReplaceStringPlaceholders( + const string16& format_string, + const std::vector<string16>& subst, + std::vector<size_t>* offsets); -BASE_API std::string ReplaceStringPlaceholders( +BASE_EXPORT std::string ReplaceStringPlaceholders( const base::StringPiece& format_string, const std::vector<std::string>& subst, std::vector<size_t>* offsets); // Single-string shortcut for ReplaceStringHolders. |offset| may be NULL. -BASE_API string16 ReplaceStringPlaceholders(const string16& format_string, - const string16& a, - size_t* offset); +BASE_EXPORT string16 ReplaceStringPlaceholders(const string16& format_string, + const string16& a, + size_t* offset); // Returns true if the string passed in matches the pattern. The pattern // string can contain wildcards like * and ? // The backslash character (\) is an escape character for * and ? // We limit the patterns to having a max of 16 * or ? characters. // ? matches 0 or 1 character, while * matches 0 or more characters. -BASE_API bool MatchPattern(const base::StringPiece& string, - const base::StringPiece& pattern); -BASE_API bool MatchPattern(const string16& string, const string16& pattern); +BASE_EXPORT bool MatchPattern(const base::StringPiece& string, + const base::StringPiece& pattern); +BASE_EXPORT bool MatchPattern(const string16& string, const string16& pattern); // Hack to convert any char-like type to its unsigned counterpart. // For example, it will convert char, signed char and unsigned char to unsigned diff --git a/base/stringprintf.h b/base/stringprintf.h index fb32f20..40ad107 100644 --- a/base/stringprintf.h +++ b/base/stringprintf.h @@ -9,42 +9,43 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/compiler_specific.h" namespace base { // Return a C++ string given printf-like input. -BASE_API std::string StringPrintf(const char* format, ...) PRINTF_FORMAT(1, 2); -BASE_API std::wstring StringPrintf(const wchar_t* format, ...) +BASE_EXPORT std::string StringPrintf(const char* format, ...) + PRINTF_FORMAT(1, 2); +BASE_EXPORT std::wstring StringPrintf(const wchar_t* format, ...) WPRINTF_FORMAT(1, 2); // Return a C++ string given vprintf-like input. -BASE_API std::string StringPrintV(const char* format, va_list ap) +BASE_EXPORT std::string StringPrintV(const char* format, va_list ap) PRINTF_FORMAT(1, 0); // Store result into a supplied string and return it. -BASE_API const std::string& SStringPrintf(std::string* dst, - const char* format, ...) +BASE_EXPORT const std::string& SStringPrintf(std::string* dst, + const char* format, ...) PRINTF_FORMAT(2, 3); -BASE_API const std::wstring& SStringPrintf(std::wstring* dst, - const wchar_t* format, ...) +BASE_EXPORT const std::wstring& SStringPrintf(std::wstring* dst, + const wchar_t* format, ...) WPRINTF_FORMAT(2, 3); // Append result to a supplied string. -BASE_API void StringAppendF(std::string* dst, const char* format, ...) +BASE_EXPORT void StringAppendF(std::string* dst, const char* format, ...) PRINTF_FORMAT(2, 3); // TODO(evanm): this is only used in a few places in the code; // replace with string16 version. -BASE_API void StringAppendF(std::wstring* dst, const wchar_t* format, ...) +BASE_EXPORT void StringAppendF(std::wstring* dst, const wchar_t* format, ...) WPRINTF_FORMAT(2, 3); // Lower-level routine that takes a va_list and appends to a specified // string. All other routines are just convenience wrappers around it. -BASE_API void StringAppendV(std::string* dst, const char* format, va_list ap) +BASE_EXPORT void StringAppendV(std::string* dst, const char* format, va_list ap) PRINTF_FORMAT(2, 0); -BASE_API void StringAppendV(std::wstring* dst, - const wchar_t* format, va_list ap) +BASE_EXPORT void StringAppendV(std::wstring* dst, + const wchar_t* format, va_list ap) WPRINTF_FORMAT(2, 0); } // namespace base diff --git a/base/sync_socket.h b/base/sync_socket.h index bcebbdfa..221e7b0 100644 --- a/base/sync_socket.h +++ b/base/sync_socket.h @@ -16,11 +16,11 @@ #endif #include <sys/types.h> -#include "base/base_api.h" +#include "base/base_export.h" namespace base { -class BASE_API SyncSocket { +class BASE_EXPORT SyncSocket { public: #if defined(OS_WIN) typedef HANDLE Handle; diff --git a/base/synchronization/cancellation_flag.h b/base/synchronization/cancellation_flag.h index 5738929..7734b34 100644 --- a/base/synchronization/cancellation_flag.h +++ b/base/synchronization/cancellation_flag.h @@ -6,7 +6,7 @@ #define BASE_SYNCHRONIZATION_CANCELLATION_FLAG_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/atomicops.h" #include "base/threading/platform_thread.h" @@ -17,7 +17,7 @@ namespace base { // is thread-safe. // // This class IS NOT intended for synchronization between threads. -class BASE_API CancellationFlag { +class BASE_EXPORT CancellationFlag { public: CancellationFlag() : flag_(false) { #if !defined(NDEBUG) diff --git a/base/synchronization/condition_variable.h b/base/synchronization/condition_variable.h index d70d4cd..1b3b2ff 100644 --- a/base/synchronization/condition_variable.h +++ b/base/synchronization/condition_variable.h @@ -74,7 +74,7 @@ #include <pthread.h> #endif -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/synchronization/lock.h" @@ -82,7 +82,7 @@ namespace base { class TimeDelta; -class BASE_API ConditionVariable { +class BASE_EXPORT ConditionVariable { public: // Construct a cv for use with ONLY one user lock. explicit ConditionVariable(Lock* user_lock); diff --git a/base/synchronization/lock.h b/base/synchronization/lock.h index 46d1ab3..f3a685e 100644 --- a/base/synchronization/lock.h +++ b/base/synchronization/lock.h @@ -6,7 +6,7 @@ #define BASE_SYNCHRONIZATION_LOCK_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/synchronization/lock_impl.h" #include "base/threading/platform_thread.h" @@ -15,7 +15,7 @@ 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 BASE_API Lock { +class BASE_EXPORT Lock { public: #if defined(NDEBUG) // Optimized wrapper implementation Lock() : lock_() {} diff --git a/base/synchronization/lock_impl.h b/base/synchronization/lock_impl.h index 79bc147..63efc5ff 100644 --- a/base/synchronization/lock_impl.h +++ b/base/synchronization/lock_impl.h @@ -14,7 +14,7 @@ #include <pthread.h> #endif -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -23,7 +23,7 @@ namespace internal { // This class implements the underlying platform-specific spin-lock mechanism // used for the Lock class. Most users should not use LockImpl directly, but // should instead use Lock. -class BASE_API LockImpl { +class BASE_EXPORT LockImpl { public: #if defined(OS_WIN) typedef CRITICAL_SECTION OSLockType; diff --git a/base/synchronization/waitable_event.h b/base/synchronization/waitable_event.h index 1ab20fa..62712ed 100644 --- a/base/synchronization/waitable_event.h +++ b/base/synchronization/waitable_event.h @@ -6,7 +6,7 @@ #define BASE_SYNCHRONIZATION_WAITABLE_EVENT_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #if defined(OS_WIN) @@ -42,7 +42,7 @@ class TimeDelta; // by a Windows event object. This is intentional. If you are writing Windows // specific code and you need other features of a Windows event, then you might // be better off just using an Windows event directly. -class BASE_API WaitableEvent { +class BASE_EXPORT WaitableEvent { public: // If manual_reset is true, then to set the event state to non-signaled, a // consumer must call the Reset method. If this parameter is false, then the diff --git a/base/synchronization/waitable_event_watcher.h b/base/synchronization/waitable_event_watcher.h index 6e1d197..116e274 100644 --- a/base/synchronization/waitable_event_watcher.h +++ b/base/synchronization/waitable_event_watcher.h @@ -15,7 +15,7 @@ #include "base/synchronization/waitable_event.h" #endif -#include "base/base_api.h" +#include "base/base_export.h" namespace base { @@ -60,7 +60,7 @@ class WaitableEvent; // it with a Watcher. It will act as if the event was never signaled. // ----------------------------------------------------------------------------- -class BASE_API WaitableEventWatcher +class BASE_EXPORT WaitableEventWatcher #if defined(OS_POSIX) : public MessageLoop::DestructionObserver #endif diff --git a/base/sys_info.h b/base/sys_info.h index 0d23775..f3677d6 100644 --- a/base/sys_info.h +++ b/base/sys_info.h @@ -6,7 +6,7 @@ #define BASE_SYS_INFO_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include <string> @@ -15,7 +15,7 @@ class FilePath; namespace base { -class BASE_API SysInfo { +class BASE_EXPORT SysInfo { public: // Return the number of logical processors/cores on the current machine. static int NumberOfProcessors(); diff --git a/base/sys_string_conversions.h b/base/sys_string_conversions.h index fefc2fa..d2f4d1b 100644 --- a/base/sys_string_conversions.h +++ b/base/sys_string_conversions.h @@ -12,7 +12,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/string16.h" @@ -31,14 +31,14 @@ class StringPiece; // Converts between wide and UTF-8 representations of a string. On error, the // result is system-dependent. -BASE_API std::string SysWideToUTF8(const std::wstring& wide); -BASE_API std::wstring SysUTF8ToWide(const StringPiece& utf8); +BASE_EXPORT std::string SysWideToUTF8(const std::wstring& wide); +BASE_EXPORT std::wstring SysUTF8ToWide(const StringPiece& utf8); // Converts between wide and the system multi-byte representations of a string. // DANGER: This will lose information and can change (on Windows, this can // change between reboots). -BASE_API std::string SysWideToNativeMB(const std::wstring& wide); -BASE_API std::wstring SysNativeMBToWide(const StringPiece& native_mb); +BASE_EXPORT std::string SysWideToNativeMB(const std::wstring& wide); +BASE_EXPORT std::wstring SysNativeMBToWide(const StringPiece& native_mb); // Windows-specific ------------------------------------------------------------ @@ -47,10 +47,10 @@ BASE_API std::wstring SysNativeMBToWide(const StringPiece& native_mb); // Converts between 8-bit and wide strings, using the given code page. The // code page identifier is one accepted by the Windows function // MultiByteToWideChar(). -BASE_API std::wstring SysMultiByteToWide(const StringPiece& mb, - uint32 code_page); -BASE_API std::string SysWideToMultiByte(const std::wstring& wide, - uint32 code_page); +BASE_EXPORT std::wstring SysMultiByteToWide(const StringPiece& mb, + uint32 code_page); +BASE_EXPORT std::string SysWideToMultiByte(const std::wstring& wide, + uint32 code_page); #endif // defined(OS_WIN) @@ -62,25 +62,25 @@ BASE_API std::string SysWideToMultiByte(const std::wstring& wide, // Creates a string, and returns it with a refcount of 1. You are responsible // for releasing it. Returns NULL on failure. -BASE_API CFStringRef SysUTF8ToCFStringRef(const std::string& utf8); -BASE_API CFStringRef SysUTF16ToCFStringRef(const string16& utf16); -BASE_API CFStringRef SysWideToCFStringRef(const std::wstring& wide); +BASE_EXPORT CFStringRef SysUTF8ToCFStringRef(const std::string& utf8); +BASE_EXPORT CFStringRef SysUTF16ToCFStringRef(const string16& utf16); +BASE_EXPORT CFStringRef SysWideToCFStringRef(const std::wstring& wide); // Same, but returns an autoreleased NSString. -BASE_API NSString* SysUTF8ToNSString(const std::string& utf8); -BASE_API NSString* SysUTF16ToNSString(const string16& utf16); -BASE_API NSString* SysWideToNSString(const std::wstring& wide); +BASE_EXPORT NSString* SysUTF8ToNSString(const std::string& utf8); +BASE_EXPORT NSString* SysUTF16ToNSString(const string16& utf16); +BASE_EXPORT NSString* SysWideToNSString(const std::wstring& wide); // Converts a CFStringRef to an STL string. Returns an empty string on failure. -BASE_API std::string SysCFStringRefToUTF8(CFStringRef ref); -BASE_API string16 SysCFStringRefToUTF16(CFStringRef ref); -BASE_API std::wstring SysCFStringRefToWide(CFStringRef ref); +BASE_EXPORT std::string SysCFStringRefToUTF8(CFStringRef ref); +BASE_EXPORT string16 SysCFStringRefToUTF16(CFStringRef ref); +BASE_EXPORT std::wstring SysCFStringRefToWide(CFStringRef ref); // Same, but accepts NSString input. Converts nil NSString* to the appropriate // string type of length 0. -BASE_API std::string SysNSStringToUTF8(NSString* ref); -BASE_API string16 SysNSStringToUTF16(NSString* ref); -BASE_API std::wstring SysNSStringToWide(NSString* ref); +BASE_EXPORT std::string SysNSStringToUTF8(NSString* ref); +BASE_EXPORT string16 SysNSStringToUTF16(NSString* ref); +BASE_EXPORT std::wstring SysNSStringToWide(NSString* ref); #endif // defined(OS_MACOSX) diff --git a/base/system_monitor/system_monitor.h b/base/system_monitor/system_monitor.h index 78ab50a..c779994 100644 --- a/base/system_monitor/system_monitor.h +++ b/base/system_monitor/system_monitor.h @@ -6,7 +6,7 @@ #define BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "build/build_config.h" @@ -33,7 +33,7 @@ namespace base { // Class for monitoring various system-related subsystems // such as power management, network status, etc. // TODO(mbelshe): Add support beyond just power management. -class BASE_API SystemMonitor { +class BASE_EXPORT SystemMonitor { public: // Normalized list of power events. enum PowerEvent { @@ -74,7 +74,7 @@ class BASE_API SystemMonitor { // are finished. Observers should implement quick callback functions; if // lengthy operations are needed, the observer should take care to invoke // the operation on an appropriate thread. - class BASE_API PowerObserver { + class BASE_EXPORT PowerObserver { public: // Notification of a change in power status of the computer, such // as from switching between battery and A/C power. diff --git a/base/task.h b/base/task.h index 4bee08c..460c8c2 100644 --- a/base/task.h +++ b/base/task.h @@ -6,7 +6,7 @@ #define BASE_TASK_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/debug/alias.h" #include "base/memory/raw_scoped_refptr_mismatch_checker.h" #include "base/memory/weak_ptr.h" @@ -22,7 +22,7 @@ const size_t kDeadTask = 0xDEAD7A53; // 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 BASE_API Task : public tracked_objects::Tracked { +class BASE_EXPORT Task : public tracked_objects::Tracked { public: Task(); virtual ~Task(); @@ -31,7 +31,7 @@ class BASE_API Task : public tracked_objects::Tracked { virtual void Run() = 0; }; -class BASE_API CancelableTask : public Task { +class BASE_EXPORT CancelableTask : public Task { public: CancelableTask(); virtual ~CancelableTask(); @@ -550,7 +550,7 @@ namespace base { // ScopedTaskRunner is akin to scoped_ptr for Tasks. It ensures that the Task // is executed and deleted no matter how the current scope exits. -class BASE_API ScopedTaskRunner { +class BASE_EXPORT ScopedTaskRunner { public: // Takes ownership of the task. explicit ScopedTaskRunner(Task* task); diff --git a/base/task_queue.h b/base/task_queue.h index 45a43e9..877201c4 100644 --- a/base/task_queue.h +++ b/base/task_queue.h @@ -8,13 +8,13 @@ #include <deque> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/task.h" // A TaskQueue is a queue of tasks waiting to be run. To run the tasks, call // the Run method. A task queue is itself a Task so that it can be placed in a // message loop or another task queue. -class BASE_API TaskQueue : public Task { +class BASE_EXPORT TaskQueue : public Task { public: TaskQueue(); virtual ~TaskQueue(); diff --git a/base/third_party/nspr/prtime.h b/base/third_party/nspr/prtime.h index a207021..ffbedec 100644 --- a/base/third_party/nspr/prtime.h +++ b/base/third_party/nspr/prtime.h @@ -52,7 +52,7 @@ #ifndef BASE_PRTIME_H__ #define BASE_PRTIME_H__ -#include "base/base_api.h" +#include "base/base_export.h" #include "base/third_party/nspr/prtypes.h" #define PR_ASSERT DCHECK @@ -230,7 +230,7 @@ NSPR_API(PRTimeParameters) PR_GMTParameters(const PRExplodedTime *gmt); * from the unit test. */ -BASE_API PRStatus PR_ParseTimeString ( +BASE_EXPORT PRStatus PR_ParseTimeString ( const char *string, PRBool default_to_gmt, PRTime *result); diff --git a/base/threading/non_thread_safe_impl.h b/base/threading/non_thread_safe_impl.h index ab0999a..4a70e34 100644 --- a/base/threading/non_thread_safe_impl.h +++ b/base/threading/non_thread_safe_impl.h @@ -6,7 +6,7 @@ #define BASE_THREADING_NON_THREAD_SAFE_IMPL_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/threading/thread_checker_impl.h" namespace base { @@ -17,7 +17,7 @@ namespace base { // // Note: You should almost always use the NonThreadSafe class to get // the right version of the class for your build configuration. -class BASE_API NonThreadSafeImpl { +class BASE_EXPORT NonThreadSafeImpl { public: ~NonThreadSafeImpl(); diff --git a/base/threading/platform_thread.h b/base/threading/platform_thread.h index 230d209..4703b96 100644 --- a/base/threading/platform_thread.h +++ b/base/threading/platform_thread.h @@ -10,7 +10,7 @@ #define BASE_THREADING_PLATFORM_THREAD_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "build/build_config.h" @@ -55,11 +55,11 @@ enum ThreadPriority{ }; // A namespace for low-level thread functions. -class BASE_API PlatformThread { +class BASE_EXPORT PlatformThread { public: // Implement this interface to run code on a background thread. Your // ThreadMain method will be called on the newly created thread. - class BASE_API Delegate { + class BASE_EXPORT Delegate { public: virtual ~Delegate() {} virtual void ThreadMain() = 0; diff --git a/base/threading/simple_thread.h b/base/threading/simple_thread.h index 5d8c458..ae36f26 100644 --- a/base/threading/simple_thread.h +++ b/base/threading/simple_thread.h @@ -45,7 +45,7 @@ #include <queue> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/threading/platform_thread.h" #include "base/synchronization/lock.h" @@ -55,9 +55,9 @@ namespace base { // This is the base SimpleThread. You can derive from it and implement the // virtual Run method, or you can use the DelegateSimpleThread interface. -class BASE_API SimpleThread : public PlatformThread::Delegate { +class BASE_EXPORT SimpleThread : public PlatformThread::Delegate { public: - class BASE_API Options { + class BASE_EXPORT Options { public: Options() : stack_size_(0) { } ~Options() { } @@ -120,9 +120,9 @@ class BASE_API SimpleThread : public PlatformThread::Delegate { bool joined_; // True if Join has been called. }; -class BASE_API DelegateSimpleThread : public SimpleThread { +class BASE_EXPORT DelegateSimpleThread : public SimpleThread { public: - class BASE_API Delegate { + class BASE_EXPORT Delegate { public: Delegate() { } virtual ~Delegate() { } @@ -150,7 +150,7 @@ class BASE_API DelegateSimpleThread : public SimpleThread { // 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 BASE_API DelegateSimpleThreadPool +class BASE_EXPORT DelegateSimpleThreadPool : public DelegateSimpleThread::Delegate { public: typedef DelegateSimpleThread::Delegate Delegate; diff --git a/base/threading/thread.h b/base/threading/thread.h index 9a181c0..58a4cc2 100644 --- a/base/threading/thread.h +++ b/base/threading/thread.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/message_loop.h" #include "base/message_loop_proxy.h" #include "base/threading/platform_thread.h" @@ -26,7 +26,7 @@ namespace base { // (1) Thread::CleanUp() // (2) MessageLoop::~MessageLoop // (3.b) MessageLoop::DestructionObserver::WillDestroyCurrentMessageLoop -class BASE_API Thread : PlatformThread::Delegate { +class BASE_EXPORT Thread : PlatformThread::Delegate { public: struct Options { Options() : message_loop_type(MessageLoop::TYPE_DEFAULT), stack_size(0) {} diff --git a/base/threading/thread_checker_impl.h b/base/threading/thread_checker_impl.h index 02ecebf..4295560 100644 --- a/base/threading/thread_checker_impl.h +++ b/base/threading/thread_checker_impl.h @@ -6,7 +6,7 @@ #define BASE_THREADING_THREAD_CHECKER_IMPL_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/synchronization/lock.h" #include "base/threading/platform_thread.h" @@ -18,7 +18,7 @@ namespace base { // // Note: You should almost always use the ThreadChecker class to get the // right version for your build configuration. -class BASE_API ThreadCheckerImpl { +class BASE_EXPORT ThreadCheckerImpl { public: ThreadCheckerImpl(); ~ThreadCheckerImpl(); diff --git a/base/threading/thread_collision_warner.h b/base/threading/thread_collision_warner.h index b26568d..4460602 100644 --- a/base/threading/thread_collision_warner.h +++ b/base/threading/thread_collision_warner.h @@ -8,7 +8,7 @@ #include <memory> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/atomicops.h" // A helper class alongside macros to be used to verify assumptions about thread @@ -131,17 +131,17 @@ namespace base { // AsserterBase is the interfaces and DCheckAsserter is the default asserter // used. During the unit tests is used another class that doesn't "DCHECK" // in case of collision (check thread_collision_warner_unittests.cc) -struct BASE_API AsserterBase { +struct BASE_EXPORT AsserterBase { virtual ~AsserterBase() {} virtual void warn() = 0; }; -struct BASE_API DCheckAsserter : public AsserterBase { +struct BASE_EXPORT DCheckAsserter : public AsserterBase { virtual ~DCheckAsserter() {} virtual void warn(); }; -class BASE_API ThreadCollisionWarner { +class BASE_EXPORT ThreadCollisionWarner { public: // The parameter asserter is there only for test purpose ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter()) @@ -158,7 +158,7 @@ class BASE_API ThreadCollisionWarner { // it doesn't leave the critical section, as opposed to ScopedCheck, // because the critical section being pinned is allowed to be used only // from one thread - class BASE_API Check { + class BASE_EXPORT Check { public: explicit Check(ThreadCollisionWarner* warner) : warner_(warner) { @@ -175,7 +175,7 @@ class BASE_API ThreadCollisionWarner { // This class is meant to be used through the macro // DFAKE_SCOPED_LOCK - class BASE_API ScopedCheck { + class BASE_EXPORT ScopedCheck { public: explicit ScopedCheck(ThreadCollisionWarner* warner) : warner_(warner) { @@ -194,7 +194,7 @@ class BASE_API ThreadCollisionWarner { // This class is meant to be used through the macro // DFAKE_SCOPED_RECURSIVE_LOCK - class BASE_API ScopedRecursiveCheck { + class BASE_EXPORT ScopedRecursiveCheck { public: explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner) : warner_(warner) { diff --git a/base/threading/thread_local.h b/base/threading/thread_local.h index 4bacf92..3cdcb94 100644 --- a/base/threading/thread_local.h +++ b/base/threading/thread_local.h @@ -49,7 +49,7 @@ #define BASE_THREADING_THREAD_LOCAL_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #if defined(OS_POSIX) @@ -61,7 +61,7 @@ namespace base { namespace internal { // Helper functions that abstract the cross-platform APIs. Do not use directly. -struct BASE_API ThreadLocalPlatform { +struct BASE_EXPORT ThreadLocalPlatform { #if defined(OS_WIN) typedef unsigned long SlotType; #elif defined(OS_POSIX) diff --git a/base/threading/thread_local_storage.h b/base/threading/thread_local_storage.h index f882729..cfac633 100644 --- a/base/threading/thread_local_storage.h +++ b/base/threading/thread_local_storage.h @@ -6,7 +6,7 @@ #define BASE_THREADING_THREAD_LOCAL_STORAGE_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #if defined(OS_POSIX) @@ -17,7 +17,7 @@ namespace base { // Wrapper for thread local storage. This class doesn't do much except provide // an API for portability. -class BASE_API ThreadLocalStorage { +class BASE_EXPORT ThreadLocalStorage { public: // Prototype for the TLS destructor function, which can be optionally used to @@ -26,7 +26,7 @@ class BASE_API ThreadLocalStorage { typedef void (*TLSDestructorFunc)(void* value); // A key representing one value stored in TLS. - class BASE_API Slot { + class BASE_EXPORT Slot { public: explicit Slot(TLSDestructorFunc destructor = NULL); diff --git a/base/threading/thread_restrictions.h b/base/threading/thread_restrictions.h index 98e0422..fc8ab4b 100644 --- a/base/threading/thread_restrictions.h +++ b/base/threading/thread_restrictions.h @@ -5,7 +5,7 @@ #ifndef BASE_THREADING_THREAD_RESTRICTIONS_H_ #define BASE_THREADING_THREAD_RESTRICTIONS_H_ -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -36,11 +36,11 @@ namespace base { // only calls other functions in Chrome and not fopen(), you should go // add the AssertIOAllowed checks in the helper functions. -class BASE_API ThreadRestrictions { +class BASE_EXPORT ThreadRestrictions { public: // Constructing a ScopedAllowIO temporarily allows IO for the current // thread. Doing this is almost certainly always incorrect. - class BASE_API ScopedAllowIO { + class BASE_EXPORT ScopedAllowIO { public: ScopedAllowIO() { previous_value_ = SetIOAllowed(true); } ~ScopedAllowIO() { SetIOAllowed(previous_value_); } @@ -53,7 +53,7 @@ class BASE_API ThreadRestrictions { // Constructing a ScopedAllowSingleton temporarily allows accessing for the // current thread. Doing this is almost always incorrect. - class BASE_API ScopedAllowSingleton { + class BASE_EXPORT ScopedAllowSingleton { public: ScopedAllowSingleton() { previous_value_ = SetSingletonAllowed(true); } ~ScopedAllowSingleton() { SetSingletonAllowed(previous_value_); } diff --git a/base/threading/watchdog.h b/base/threading/watchdog.h index fafda43..7991c30 100644 --- a/base/threading/watchdog.h +++ b/base/threading/watchdog.h @@ -21,7 +21,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/synchronization/condition_variable.h" #include "base/synchronization/lock.h" #include "base/threading/platform_thread.h" @@ -29,7 +29,7 @@ namespace base { -class BASE_API Watchdog { +class BASE_EXPORT Watchdog { public: // Constructor specifies how long the Watchdog will wait before alarming. Watchdog(const TimeDelta& duration, diff --git a/base/threading/worker_pool.h b/base/threading/worker_pool.h index 58471b5..384dcd1 100644 --- a/base/threading/worker_pool.h +++ b/base/threading/worker_pool.h @@ -6,7 +6,7 @@ #define BASE_THREADING_WORKER_POOL_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/callback.h" #include "base/tracked.h" @@ -22,7 +22,7 @@ namespace base { // inside the pool must be extremely careful about other objects they access // (MessageLoops, Singletons, etc). During shutdown these object may no longer // exist. -class BASE_API WorkerPool { +class BASE_EXPORT WorkerPool { public: // This function posts |task| to run on a worker thread. |task_is_slow| // should be used for tasks that will take a long time to execute. Returns diff --git a/base/threading/worker_pool_posix.h b/base/threading/worker_pool_posix.h index bf75c78..b1930e6 100644 --- a/base/threading/worker_pool_posix.h +++ b/base/threading/worker_pool_posix.h @@ -41,7 +41,7 @@ class Task; namespace base { -class BASE_API PosixDynamicThreadPool +class BASE_EXPORT PosixDynamicThreadPool : public RefCountedThreadSafe<PosixDynamicThreadPool> { public: class PosixDynamicThreadPoolPeer; diff --git a/base/time.h b/base/time.h index 9ece389..aa97f0a 100644 --- a/base/time.h +++ b/base/time.h @@ -26,7 +26,7 @@ #include <time.h> #include "base/atomicops.h" -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #if defined(OS_POSIX) @@ -47,7 +47,7 @@ class TimeTicks; // TimeDelta ------------------------------------------------------------------ -class BASE_API TimeDelta { +class BASE_EXPORT TimeDelta { public: TimeDelta() : delta_(0) { } @@ -177,7 +177,7 @@ inline TimeDelta operator*(int64 a, TimeDelta td) { // Time ----------------------------------------------------------------------- // Represents a wall clock time. -class BASE_API Time { +class BASE_EXPORT Time { public: static const int64 kMillisecondsPerSecond = 1000; static const int64 kMicrosecondsPerMillisecond = 1000; @@ -203,7 +203,7 @@ class BASE_API Time { // Represents an exploded time that can be formatted nicely. This is kind of // like the Win32 SYSTEMTIME structure or the Unix "struct tm" with a few // additions and changes to prevent errors. - struct BASE_API Exploded { + struct BASE_EXPORT Exploded { int year; // Four digit year "2007" int month; // 1-based month (values 1 = January, etc.) int day_of_week; // 0-based day of week (0 = Sunday, etc.) @@ -457,7 +457,7 @@ inline Time TimeDelta::operator+(Time t) const { // TimeTicks ------------------------------------------------------------------ -class BASE_API TimeTicks { +class BASE_EXPORT TimeTicks { public: TimeTicks() : ticks_(0) { } diff --git a/base/timer.h b/base/timer.h index 6fe826a..2e21582 100644 --- a/base/timer.h +++ b/base/timer.h @@ -47,7 +47,7 @@ // because they're flaky on the buildbot, but when you run them locally you // should be able to tell the difference. -#include "base/base_api.h" +#include "base/base_export.h" #include "base/logging.h" #include "base/task.h" #include "base/time.h" @@ -62,7 +62,7 @@ namespace base { // // This class exists to share code between BaseTimer<T> template instantiations. // -class BASE_API BaseTimer_Helper { +class BASE_EXPORT BaseTimer_Helper { public: // Stops the timer. ~BaseTimer_Helper() { diff --git a/base/tracked.cc b/base/tracked.cc index 7ca18fd..124e721 100644 --- a/base/tracked.cc +++ b/base/tracked.cc @@ -74,7 +74,7 @@ void Location::WriteFunctionName(std::string* output) const { #if defined(COMPILER_MSVC) __declspec(noinline) #endif -BASE_API const void* GetProgramCounter() { +BASE_EXPORT const void* GetProgramCounter() { #if defined(COMPILER_MSVC) return _ReturnAddress(); #elif defined(COMPILER_GCC) diff --git a/base/tracked.h b/base/tracked.h index af7029e..3c73519 100644 --- a/base/tracked.h +++ b/base/tracked.h @@ -21,7 +21,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/time.h" #ifndef NDEBUG @@ -36,7 +36,7 @@ namespace tracked_objects { // Location provides basic info where of an object was constructed, or was // significantly brought to life. -class BASE_API Location { +class BASE_EXPORT Location { public: // Constructor should be called with a long-lived char*, such as __FILE__. // It assumes the provided value will persist as a global constant, and it @@ -81,7 +81,7 @@ class BASE_API Location { const void* const program_counter_; }; -BASE_API const void* GetProgramCounter(); +BASE_EXPORT const void* GetProgramCounter(); //------------------------------------------------------------------------------ // Define a macro to record the current source location. @@ -98,7 +98,7 @@ BASE_API const void* GetProgramCounter(); class Births; -class BASE_API Tracked { +class BASE_EXPORT Tracked { public: Tracked(); virtual ~Tracked(); diff --git a/base/tracked_objects.h b/base/tracked_objects.h index b6ab345..6044408 100644 --- a/base/tracked_objects.h +++ b/base/tracked_objects.h @@ -10,7 +10,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/synchronization/lock.h" #include "base/tracked.h" #include "base/threading/thread_local_storage.h" @@ -157,7 +157,7 @@ namespace tracked_objects { // For a specific thread, and a specific birth place, the collection of all // death info (with tallies for each death thread, to prevent access conflicts). class ThreadData; -class BASE_API BirthOnThread { +class BASE_EXPORT BirthOnThread { public: explicit BirthOnThread(const Location& location); @@ -180,7 +180,7 @@ class BASE_API BirthOnThread { //------------------------------------------------------------------------------ // A class for accumulating counts of births (without bothering with a map<>). -class BASE_API Births: public BirthOnThread { +class BASE_EXPORT Births: public BirthOnThread { public: explicit Births(const Location& location); @@ -208,7 +208,7 @@ class BASE_API Births: public BirthOnThread { // birthplace (fixed Location). Used both on specific threads, and also used // in snapshots when integrating assembled data. -class BASE_API DeathData { +class BASE_EXPORT DeathData { public: // Default initializer. DeathData() : count_(0), square_duration_(0) {} @@ -249,7 +249,7 @@ class BASE_API DeathData { // The source of this data was collected on many threads, and is asynchronously // changing. The data in this instance is not asynchronously changing. -class BASE_API Snapshot { +class BASE_EXPORT Snapshot { public: // When snapshotting a full life cycle set (birth-to-death), use this: Snapshot(const BirthOnThread& birth_on_thread, const ThreadData& death_thread, @@ -285,7 +285,7 @@ class BASE_API Snapshot { // items. It protects the gathering under locks, so that it could be called via // Posttask on any threads, or passed to all the target threads in parallel. -class BASE_API DataCollector { +class BASE_EXPORT DataCollector { public: typedef std::vector<Snapshot> Collection; @@ -332,7 +332,7 @@ class BASE_API DataCollector { // Aggregation contains summaries (totals and subtotals) of groups of Snapshot // instances to provide printing of these collections on a single line. -class BASE_API Aggregation: public DeathData { +class BASE_EXPORT Aggregation: public DeathData { public: Aggregation(); ~Aggregation(); @@ -364,7 +364,7 @@ class BASE_API Aggregation: public DeathData { // instances within the groups (for detailed rendering of the instances in an // aggregation). -class BASE_API Comparator { +class BASE_EXPORT Comparator { public: // Selector enum is the token identifier for each parsed keyword, most of // which specify a sort order. @@ -465,7 +465,7 @@ class BASE_API Comparator { // For each thread, we have a ThreadData that stores all tracking info generated // on this thread. This prevents the need for locking as data accumulates. -class BASE_API ThreadData { +class BASE_EXPORT ThreadData { public: typedef std::map<Location, Births*> BirthMap; typedef std::map<const Births*, DeathData> DeathMap; @@ -638,7 +638,7 @@ class BASE_API ThreadData { // only allow the tracking system to be started up at most once, and shutdown // at most once. See bug 31344 for an example. -class BASE_API AutoTracking { +class BASE_EXPORT AutoTracking { public: AutoTracking() { if (state_ != kNeverBeenRun) diff --git a/base/utf_offset_string_conversions.h b/base/utf_offset_string_conversions.h index 4c87f83..01177b6 100644 --- a/base/utf_offset_string_conversions.h +++ b/base/utf_offset_string_conversions.h @@ -9,7 +9,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string16.h" namespace base { @@ -22,19 +22,19 @@ class StringPiece; // If this isn't possible because an offset points past the end of the source // strings or into the middle of a multibyte sequence, the offending offset will // be set to string16::npos. |offset[s]_for_adjustment| may be NULL. -BASE_API bool UTF8ToUTF16AndAdjustOffset(const char* src, - size_t src_len, - string16* output, - size_t* offset_for_adjustment); -BASE_API bool UTF8ToUTF16AndAdjustOffsets( +BASE_EXPORT bool UTF8ToUTF16AndAdjustOffset(const char* src, + size_t src_len, + string16* output, + size_t* offset_for_adjustment); +BASE_EXPORT bool UTF8ToUTF16AndAdjustOffsets( const char* src, size_t src_len, string16* output, std::vector<size_t>* offsets_for_adjustment); -BASE_API string16 UTF8ToUTF16AndAdjustOffset(const base::StringPiece& utf8, - size_t* offset_for_adjustment); -BASE_API string16 UTF8ToUTF16AndAdjustOffsets( +BASE_EXPORT string16 UTF8ToUTF16AndAdjustOffset(const base::StringPiece& utf8, + size_t* offset_for_adjustment); +BASE_EXPORT string16 UTF8ToUTF16AndAdjustOffsets( const base::StringPiece& utf8, std::vector<size_t>* offsets_for_adjustment); @@ -59,9 +59,9 @@ struct LimitOffset { // (each Adjustment gives the |original_offset| of a substring and the lengths // of the substring before and after transforming). When the OffsetAdjuster // goes out of scope, all the offsets in the provided vector will be updated. -class BASE_API OffsetAdjuster { +class BASE_EXPORT OffsetAdjuster { public: - struct BASE_API Adjustment { + struct BASE_EXPORT Adjustment { Adjustment(size_t original_offset, size_t original_length, size_t output_length); diff --git a/base/utf_string_conversion_utils.h b/base/utf_string_conversion_utils.h index d86d8a3..b100112 100644 --- a/base/utf_string_conversion_utils.h +++ b/base/utf_string_conversion_utils.h @@ -8,7 +8,7 @@ // This should only be used by the various UTF string conversion files. -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string16.h" namespace base { @@ -38,23 +38,23 @@ inline bool IsValidCharacter(uint32 code_point) { // (as in a for loop) will take the reader to the next character. // // Returns true on success. On false, |*code_point| will be invalid. -BASE_API bool ReadUnicodeCharacter(const char* src, - int32 src_len, - int32* char_index, - uint32* code_point_out); +BASE_EXPORT bool ReadUnicodeCharacter(const char* src, + int32 src_len, + int32* char_index, + uint32* code_point_out); // Reads a UTF-16 character. The usage is the same as the 8-bit version above. -BASE_API bool ReadUnicodeCharacter(const char16* src, - int32 src_len, - int32* char_index, - uint32* code_point); +BASE_EXPORT bool ReadUnicodeCharacter(const char16* src, + int32 src_len, + int32* char_index, + uint32* code_point); #if defined(WCHAR_T_IS_UTF32) // Reads UTF-32 character. The usage is the same as the 8-bit version above. -BASE_API bool ReadUnicodeCharacter(const wchar_t* src, - int32 src_len, - int32* char_index, - uint32* code_point); +BASE_EXPORT bool ReadUnicodeCharacter(const wchar_t* src, + int32 src_len, + int32* char_index, + uint32* code_point); #endif // defined(WCHAR_T_IS_UTF32) // WriteUnicodeCharacter ------------------------------------------------------- @@ -62,7 +62,8 @@ BASE_API bool ReadUnicodeCharacter(const wchar_t* src, // Appends a UTF-8 character to the given 8-bit string. Returns the number of // bytes written. // TODO(brettw) Bug 79631: This function should not be exposed. -BASE_API size_t WriteUnicodeCharacter(uint32 code_point, std::string* output); +BASE_EXPORT size_t WriteUnicodeCharacter(uint32 code_point, + std::string* output); // Appends the given code point as a UTF-16 character to the given 16-bit // string. Returns the number of 16-bit values written. diff --git a/base/utf_string_conversions.h b/base/utf_string_conversions.h index 9e4af87..cd5a802 100644 --- a/base/utf_string_conversions.h +++ b/base/utf_string_conversions.h @@ -8,7 +8,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string16.h" #include "base/string_piece.h" @@ -18,23 +18,25 @@ // do the best it can and put the result in the output buffer. The versions that // return strings ignore this error and just return the best conversion // possible. -BASE_API bool WideToUTF8(const wchar_t* src, size_t src_len, - std::string* output); -BASE_API std::string WideToUTF8(const std::wstring& wide); -BASE_API bool UTF8ToWide(const char* src, size_t src_len, std::wstring* output); -BASE_API std::wstring UTF8ToWide(const base::StringPiece& utf8); - -BASE_API bool WideToUTF16(const wchar_t* src, size_t src_len, string16* output); -BASE_API string16 WideToUTF16(const std::wstring& wide); -BASE_API bool UTF16ToWide(const char16* src, size_t src_len, - std::wstring* output); -BASE_API std::wstring UTF16ToWide(const string16& utf16); - -BASE_API bool UTF8ToUTF16(const char* src, size_t src_len, string16* output); -BASE_API string16 UTF8ToUTF16(const base::StringPiece& utf8); -BASE_API bool UTF16ToUTF8(const char16* src, size_t src_len, - std::string* output); -BASE_API std::string UTF16ToUTF8(const string16& utf16); +BASE_EXPORT bool WideToUTF8(const wchar_t* src, size_t src_len, + std::string* output); +BASE_EXPORT std::string WideToUTF8(const std::wstring& wide); +BASE_EXPORT bool UTF8ToWide(const char* src, size_t src_len, + std::wstring* output); +BASE_EXPORT std::wstring UTF8ToWide(const base::StringPiece& utf8); + +BASE_EXPORT bool WideToUTF16(const wchar_t* src, size_t src_len, + string16* output); +BASE_EXPORT string16 WideToUTF16(const std::wstring& wide); +BASE_EXPORT bool UTF16ToWide(const char16* src, size_t src_len, + std::wstring* output); +BASE_EXPORT std::wstring UTF16ToWide(const string16& utf16); + +BASE_EXPORT bool UTF8ToUTF16(const char* src, size_t src_len, string16* output); +BASE_EXPORT string16 UTF8ToUTF16(const base::StringPiece& utf8); +BASE_EXPORT bool UTF16ToUTF8(const char16* src, size_t src_len, + std::string* output); +BASE_EXPORT std::string UTF16ToUTF8(const string16& utf16); // We are trying to get rid of wstring as much as possible, but it's too big // a mess to do it all at once. These conversions should be used when we @@ -51,7 +53,7 @@ BASE_API std::string UTF16ToUTF8(const string16& utf16); // These convert an ASCII string, typically a hardcoded constant, to a // UTF16/Wide string. -BASE_API std::wstring ASCIIToWide(const base::StringPiece& ascii); -BASE_API string16 ASCIIToUTF16(const base::StringPiece& ascii); +BASE_EXPORT std::wstring ASCIIToWide(const base::StringPiece& ascii); +BASE_EXPORT string16 ASCIIToUTF16(const base::StringPiece& ascii); #endif // BASE_UTF_STRING_CONVERSIONS_H_ diff --git a/base/value_conversions.h b/base/value_conversions.h index 5ed7550c..c65e627 100644 --- a/base/value_conversions.h +++ b/base/value_conversions.h @@ -8,7 +8,7 @@ // This file contains methods to convert a |FilePath| to a |Value| and back. -#include "base/base_api.h" +#include "base/base_export.h" class FilePath; @@ -18,8 +18,8 @@ class StringValue; class Value; // The caller takes ownership of the returned value. -BASE_API StringValue* CreateFilePathValue(const FilePath& in_value); -BASE_API bool GetValueAsFilePath(const Value& value, FilePath* file_path); +BASE_EXPORT StringValue* CreateFilePathValue(const FilePath& in_value); +BASE_EXPORT bool GetValueAsFilePath(const Value& value, FilePath* file_path); } // namespace diff --git a/base/values.h b/base/values.h index 55e7be0..479beef 100644 --- a/base/values.h +++ b/base/values.h @@ -27,7 +27,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/string16.h" #include "build/build_config.h" @@ -52,7 +52,7 @@ typedef std::map<std::string, Value*> ValueMap; // The Value class is the base class for Values. A Value can be // instantiated via the Create*Value() factory methods, or by directly // creating instances of the subclasses. -class BASE_API Value { +class BASE_EXPORT Value { public: enum ValueType { TYPE_NULL = 0, @@ -131,7 +131,7 @@ class BASE_API Value { }; // FundamentalValue represents the simple fundamental types of values. -class BASE_API FundamentalValue : public Value { +class BASE_EXPORT FundamentalValue : public Value { public: explicit FundamentalValue(bool in_value); explicit FundamentalValue(int in_value); @@ -155,7 +155,7 @@ class BASE_API FundamentalValue : public Value { DISALLOW_COPY_AND_ASSIGN(FundamentalValue); }; -class BASE_API StringValue : public Value { +class BASE_EXPORT StringValue : public Value { public: // Initializes a StringValue with a UTF-8 narrow character string. explicit StringValue(const std::string& in_value); @@ -177,7 +177,7 @@ class BASE_API StringValue : public Value { DISALLOW_COPY_AND_ASSIGN(StringValue); }; -class BASE_API BinaryValue: public Value { +class BASE_EXPORT BinaryValue: public Value { public: virtual ~BinaryValue(); @@ -214,7 +214,7 @@ class BASE_API BinaryValue: public Value { // DictionaryValue provides a key-value dictionary with (optional) "path" // parsing for recursive access; see the comment at the top of the file. Keys // are |std::string|s and should be UTF-8 encoded. -class BASE_API DictionaryValue : public Value { +class BASE_EXPORT DictionaryValue : public Value { public: DictionaryValue(); virtual ~DictionaryValue(); @@ -357,7 +357,7 @@ class BASE_API DictionaryValue : public Value { }; // This type of Value represents a list of other Value values. -class BASE_API ListValue : public Value { +class BASE_EXPORT ListValue : public Value { public: typedef ValueVector::iterator iterator; typedef ValueVector::const_iterator const_iterator; @@ -447,7 +447,7 @@ class BASE_API ListValue : public Value { // This interface is implemented by classes that know how to serialize and // deserialize Value objects. -class BASE_API ValueSerializer { +class BASE_EXPORT ValueSerializer { public: virtual ~ValueSerializer(); diff --git a/base/version.h b/base/version.h index b61cbb5..2ea4101 100644 --- a/base/version.h +++ b/base/version.h @@ -9,13 +9,13 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/gtest_prod_util.h" // Version represents a dotted version number, like "1.2.3.4", supporting // parsing and comparison. -class BASE_API Version { +class BASE_EXPORT Version { public: // The only thing you can legally do to a default constructed // Version object is assign to it. diff --git a/base/vlog.h b/base/vlog.h index 0a55006..fde6ea6 100644 --- a/base/vlog.h +++ b/base/vlog.h @@ -10,14 +10,14 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" #include "base/string_piece.h" namespace logging { // A helper class containing all the settings for vlogging. -class BASE_API VlogInfo { +class BASE_EXPORT VlogInfo { public: static const int kDefaultVlogLevel; @@ -71,8 +71,8 @@ class BASE_API VlogInfo { // "kh*n" matches "khn", "khan", or even "khaaaaan" // "/foo\bar" matches "/foo/bar", "\foo\bar", or "/foo\bar" // (disregarding C escaping rules) -BASE_API bool MatchVlogPattern(const base::StringPiece& string, - const base::StringPiece& vlog_pattern); +BASE_EXPORT bool MatchVlogPattern(const base::StringPiece& string, + const base::StringPiece& vlog_pattern); } // namespace logging diff --git a/base/win/event_trace_controller.h b/base/win/event_trace_controller.h index 6cc7e69..8f8d476 100644 --- a/base/win/event_trace_controller.h +++ b/base/win/event_trace_controller.h @@ -26,7 +26,7 @@ #include <evntrace.h> #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -35,7 +35,7 @@ namespace win { // Utility class to make it easier to work with EVENT_TRACE_PROPERTIES. // The EVENT_TRACE_PROPERTIES structure contains information about an // event tracing session. -class BASE_API EtwTraceProperties { +class BASE_EXPORT EtwTraceProperties { public: EtwTraceProperties(); @@ -85,7 +85,7 @@ class BASE_API EtwTraceProperties { // This class implements an ETW controller, which knows how to start and // stop event tracing sessions, as well as controlling ETW provider // log levels and enable bit masks under the session. -class BASE_API EtwTraceController { +class BASE_EXPORT EtwTraceController { public: EtwTraceController(); ~EtwTraceController(); diff --git a/base/win/event_trace_provider.h b/base/win/event_trace_provider.h index 7173025..35f3efe 100644 --- a/base/win/event_trace_provider.h +++ b/base/win/event_trace_provider.h @@ -12,7 +12,7 @@ #include <wmistr.h> #include <evntrace.h> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -82,7 +82,7 @@ template <size_t N> class EtwMofEvent: public EtwMofEventBase<N> { // a particular trace level, and whether particular enable flags are set, // before other resources are consumed to generate and issue the log // messages themselves. -class BASE_API EtwTraceProvider { +class BASE_EXPORT EtwTraceProvider { public: // Creates an event trace provider identified by provider_name, which // will be the name registered with Event Tracing for Windows (ETW). diff --git a/base/win/i18n.h b/base/win/i18n.h index 0159fd0..8797bd3 100644 --- a/base/win/i18n.h +++ b/base/win/i18n.h @@ -9,7 +9,7 @@ #include <string> #include <vector> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -19,13 +19,13 @@ namespace i18n { // Adds to |languages| the list of user preferred UI languages from MUI, if // available, falling-back on the user default UI language otherwise. Returns // true if at least one language is added. -BASE_API bool GetUserPreferredUILanguageList( +BASE_EXPORT bool GetUserPreferredUILanguageList( std::vector<std::wstring>* languages); // Adds to |languages| the list of thread, process, user, and system preferred // UI languages from MUI, if available, falling-back on the user default UI // language otherwise. Returns true if at least one language is added. -BASE_API bool GetThreadPreferredUILanguageList( +BASE_EXPORT bool GetThreadPreferredUILanguageList( std::vector<std::wstring>* languages); } // namespace i18n diff --git a/base/win/iat_patch_function.h b/base/win/iat_patch_function.h index 3f9acc7..34d73ba 100644 --- a/base/win/iat_patch_function.h +++ b/base/win/iat_patch_function.h @@ -8,7 +8,7 @@ #include <windows.h> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -21,7 +21,7 @@ namespace win { // This is the case when, for example, we want to intercept // CertDuplicateCertificateContext function (exported from crypt32.dll) called // by wininet.dll. -class BASE_API IATPatchFunction { +class BASE_EXPORT IATPatchFunction { public: IATPatchFunction(); ~IATPatchFunction(); diff --git a/base/win/object_watcher.h b/base/win/object_watcher.h index 7e2de77..f5a46eb 100644 --- a/base/win/object_watcher.h +++ b/base/win/object_watcher.h @@ -8,7 +8,7 @@ #include <windows.h> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/message_loop.h" namespace base { @@ -42,9 +42,9 @@ namespace win { // scope, the watcher_ will be destroyed, and there is no need to worry about // OnObjectSignaled being called on a deleted MyClass pointer. Easy! // -class BASE_API ObjectWatcher : public MessageLoop::DestructionObserver { +class BASE_EXPORT ObjectWatcher : public MessageLoop::DestructionObserver { public: - class BASE_API Delegate { + class BASE_EXPORT Delegate { public: virtual ~Delegate() {} // Called from the MessageLoop when a signaled object is detected. To diff --git a/base/win/registry.h b/base/win/registry.h index 86785cfa..078e6e0 100644 --- a/base/win/registry.h +++ b/base/win/registry.h @@ -9,7 +9,7 @@ #include <windows.h> #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -22,7 +22,7 @@ namespace win { // Note: // ReadValue family of functions guarantee that the return arguments // are not touched in case of failure. -class BASE_API RegKey { +class BASE_EXPORT RegKey { public: RegKey(); RegKey(HKEY rootkey, const wchar_t* subkey, REGSAM access); @@ -99,7 +99,7 @@ class BASE_API RegKey { // For this application I happen to know I wont need data size larger // than MAX_PATH, but in real life this wouldn't neccessarily be // adequate. -class BASE_API RegistryValueIterator { +class BASE_EXPORT RegistryValueIterator { public: RegistryValueIterator(HKEY root_key, const wchar_t* folder_key); @@ -139,7 +139,7 @@ class BASE_API RegistryValueIterator { DISALLOW_COPY_AND_ASSIGN(RegistryValueIterator); }; -class BASE_API RegistryKeyIterator { +class BASE_EXPORT RegistryKeyIterator { public: RegistryKeyIterator(HKEY root_key, const wchar_t* folder_key); diff --git a/base/win/scoped_bstr.h b/base/win/scoped_bstr.h index 61b8969..66d7a06 100644 --- a/base/win/scoped_bstr.h +++ b/base/win/scoped_bstr.h @@ -9,7 +9,7 @@ #include <windows.h> #include <oleauto.h> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/logging.h" #include "base/string16.h" @@ -18,7 +18,7 @@ namespace win { // Manages a BSTR string pointer. // The class interface is based on scoped_ptr. -class BASE_API ScopedBstr { +class BASE_EXPORT ScopedBstr { public: ScopedBstr() : bstr_(NULL) { } diff --git a/base/win/scoped_variant.h b/base/win/scoped_variant.h index 16a52ec..5b05d07 100644 --- a/base/win/scoped_variant.h +++ b/base/win/scoped_variant.h @@ -9,7 +9,7 @@ #include <windows.h> #include <oleauto.h> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/basictypes.h" namespace base { @@ -21,7 +21,7 @@ namespace win { // Instead of inheriting from VARIANT, we take the containment approach // in order to have more control over the usage of the variant and guard // against memory leaks. -class BASE_API ScopedVariant { +class BASE_EXPORT ScopedVariant { public: // Declaration of a global variant variable that's always VT_EMPTY static const VARIANT kEmptyVariant; diff --git a/base/win/win_util.h b/base/win/win_util.h index 847c434..136a1ff 100644 --- a/base/win/win_util.h +++ b/base/win/win_util.h @@ -27,7 +27,7 @@ #include <string> -#include "base/base_api.h" +#include "base/base_export.h" #include "base/string16.h" struct IPropertyStore; @@ -37,19 +37,19 @@ typedef _tagpropertykey PROPERTYKEY; namespace base { namespace win { -BASE_API void GetNonClientMetrics(NONCLIENTMETRICS* metrics); +BASE_EXPORT void GetNonClientMetrics(NONCLIENTMETRICS* metrics); // Returns the string representing the current user sid. -BASE_API bool GetUserSidString(std::wstring* user_sid); +BASE_EXPORT bool GetUserSidString(std::wstring* user_sid); // Returns true if the shift key is currently pressed. -BASE_API bool IsShiftPressed(); +BASE_EXPORT bool IsShiftPressed(); // Returns true if the ctrl key is currently pressed. -BASE_API bool IsCtrlPressed(); +BASE_EXPORT bool IsCtrlPressed(); // Returns true if the alt key is currently pressed. -BASE_API bool IsAltPressed(); +BASE_EXPORT bool IsAltPressed(); // Returns false if user account control (UAC) has been disabled with the // EnableLUA registry flag. Returns true if user account control is enabled. @@ -57,27 +57,28 @@ BASE_API bool IsAltPressed(); // machines, might still exist and be set to 0 (UAC disabled), in which case // this function will return false. You should therefore check this flag only // if the OS is Vista or later. -BASE_API bool UserAccountControlIsEnabled(); +BASE_EXPORT bool UserAccountControlIsEnabled(); // Sets the application id in given IPropertyStore. The function is intended // for tagging application/chromium shortcut, browser window and jump list for // Win7. -BASE_API bool SetAppIdForPropertyStore(IPropertyStore* property_store, - const wchar_t* app_id); +BASE_EXPORT bool SetAppIdForPropertyStore(IPropertyStore* property_store, + const wchar_t* app_id); // Adds the specified |command| using the specified |name| to the AutoRun key. // |root_key| could be HKCU or HKLM or the root of any user hive. -BASE_API bool AddCommandToAutoRun(HKEY root_key, const string16& name, - const string16& command); +BASE_EXPORT bool AddCommandToAutoRun(HKEY root_key, const string16& name, + const string16& command); // Removes the command specified by |name| from the AutoRun key. |root_key| // could be HKCU or HKLM or the root of any user hive. -BASE_API bool RemoveCommandFromAutoRun(HKEY root_key, const string16& name); +BASE_EXPORT bool RemoveCommandFromAutoRun(HKEY root_key, const string16& name); // Reads the command specified by |name| from the AutoRun key. |root_key| // could be HKCU or HKLM or the root of any user hive. Used for unit-tests. -BASE_API bool ReadCommandFromAutoRun(HKEY root_key, - const string16& name, - string16* command); +BASE_EXPORT bool ReadCommandFromAutoRun(HKEY root_key, + const string16& name, + string16* command); + } // namespace win } // namespace base diff --git a/base/win/windows_version.h b/base/win/windows_version.h index 96f3792..296e0da 100644 --- a/base/win/windows_version.h +++ b/base/win/windows_version.h @@ -6,7 +6,7 @@ #define BASE_WIN_WINDOWS_VERSION_H_ #pragma once -#include "base/base_api.h" +#include "base/base_export.h" #include "base/memory/singleton.h" typedef void* HANDLE; @@ -29,7 +29,7 @@ enum Version { // A Singleton that can be used to query various pieces of information about the // OS and process state. -class BASE_API OSInfo { +class BASE_EXPORT OSInfo { public: struct VersionNumber { int major; @@ -98,7 +98,7 @@ class BASE_API OSInfo { // Because this is by far the most commonly-requested value from the above // singleton, we add a global-scope accessor here as syntactic sugar. -BASE_API Version GetVersion(); +BASE_EXPORT Version GetVersion(); } // namespace win } // namespace base diff --git a/base/win/wrapped_window_proc.h b/base/win/wrapped_window_proc.h index eac150e..c9916504 100644 --- a/base/win/wrapped_window_proc.h +++ b/base/win/wrapped_window_proc.h @@ -13,7 +13,7 @@ #include <windows.h> -#include "base/base_api.h" +#include "base/base_export.h" namespace base { namespace win { @@ -28,11 +28,11 @@ typedef int (__cdecl *WinProcExceptionFilter)(EXCEPTION_POINTERS* info); // Sets the filter to deal with exceptions inside a WindowProc. Returns the old // exception filter, if any. // This function should be called before any window is created. -BASE_API WinProcExceptionFilter SetWinProcExceptionFilter( +BASE_EXPORT WinProcExceptionFilter SetWinProcExceptionFilter( WinProcExceptionFilter filter); // Calls the registered exception filter. -BASE_API int CallExceptionFilter(EXCEPTION_POINTERS* info); +BASE_EXPORT int CallExceptionFilter(EXCEPTION_POINTERS* info); // Wrapper that supplies a standard exception frame for the provided WindowProc. // The normal usage is something like this: |