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
diff --git a/base/at_exit.h b/base/at_exit.h
index 06214d16..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 @@
// 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 @@
// 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 c35b344c..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..df7dc168 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
similarity index 60%
rename from base/base_api.h
rename to 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..1543ecac 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 @@
// 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.
diff --git a/base/cpu.h b/base/cpu.h
index 22ec470..9567f8b5 100644
--- a/base/cpu.h
+++ b/base/cpu.h
@@ -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 fcf36530..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 @@
// 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 bb937a07..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 @@
//
// 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 @@
// 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..02cb01f2 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 @@
// 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 @@
// 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 BASE_API TraceLog {
+class BASE_EXPORT TraceLog {
public:
static TraceLog* GetInstance();
@@ -527,7 +527,7 @@
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 @@
};
// 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 @@
// 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 @@
};
// 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 9d2a6623..8a31e071 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 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 1f7aa613..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 @@
// 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 @@
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 @@
// 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..a6bb9722 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 @@
// 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 @@
// 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 @@
//
// 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 @@
//
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
//
// 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 @@
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 @@
// 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 @@
// 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 @@
// 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 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 @@
#include <string>
-#include "base/base_api.h"
+#include "base/base_export.h"
#include "base/string16.h"
class FilePath;
@@ -38,14 +38,14 @@
// 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 @@
#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 89ac67e3e..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 @@
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 @@
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..580ec99f 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 @@
// 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 d4650e50..452afa7 100644
--- a/base/global_descriptors_posix.h
+++ b/base/global_descriptors_posix.h
@@ -34,7 +34,7 @@
// 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 @@
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 e12e0bb6..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 @@
// 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 @@
// 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 @@
// 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..c18fadad 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
// 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 @@
// 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 @@
};
#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 @@
// 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 @@
// 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 @@
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 bd69df92..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 @@
// 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 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 @@
// 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 @@
// 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 @@
// 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 @@
\
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 @@
\
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 @@
// 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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 a251fcca..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 @@
// 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 @@
// 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 @@
// 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 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 @@
//==============================================================================
// 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 @@
//==============================================================================
// 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);
diff --git a/base/md5.h b/base/md5.h
index 5a1762b0..f67c365 100644
--- a/base/md5.h
+++ b/base/md5.h
@@ -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 @@
// 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..439fda44 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 @@
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..7b55d145 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
scoped_refptr<Flag> flag_;
};
-class BASE_API WeakReferenceOwner {
+class BASE_EXPORT WeakReferenceOwner {
public:
WeakReferenceOwner();
~WeakReferenceOwner();
@@ -121,7 +121,7 @@
// 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 @@
// 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 @@
// 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 @@
// MessageLoop.
//
// NOTE: A TaskObserver implementation should be extremely fast!
- class BASE_API TaskObserver {
+ class BASE_EXPORT TaskObserver {
public:
TaskObserver();
@@ -383,7 +383,7 @@
// 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 @@
// 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 @@
// 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 d6955ba2..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 @@
// 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 @@
// 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 5fa21f76..80122ce 100644
--- a/base/message_pump_gtk.h
+++ b/base/message_pump_gtk.h
@@ -41,7 +41,7 @@
};
// 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 fd763790..2af3bcc 100644
--- a/base/message_pump_libevent.h
+++ b/base/message_pump_libevent.h
@@ -21,7 +21,7 @@
// 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 @@
// 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 @@
//
// 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 @@
// 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 @@
// 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 @@
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 @@
};
// 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 @@
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 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 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 @@
//----------------------------------------------------------------------------
// 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 @@
// 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 @@
//------------------------------------------------------------------------------
// 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 @@
//------------------------------------------------------------------------------
// 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 @@
// 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 @@
//------------------------------------------------------------------------------
// 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 @@
// 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 @@
// 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..fd862ed2 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 @@
// 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 @@
// 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 @@
// 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 8420a9e3..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 @@
// 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 @@
// 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 @@
// 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 afe909a5..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 @@
// 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 @@
// 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 @@
// 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 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 @@
#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 @@
};
// 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 @@
// 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 @@
// 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 @@
// 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 @@
//
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
};
// 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 @@
#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 @@
// 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 8320ba66..f16d2647 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 @@
// 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..26d15cf5 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 @@
// 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 e72c836e..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 @@
// 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..65a45a45 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 @@
// 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 @@
// 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..c9dfd6eb 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 @@
// 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..4c7b21f8 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 @@
// 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 @@
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..6cf6a76b 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 @@
// 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 @@
// - 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_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_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_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_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_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_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 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 @@
// 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 @@
// 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 @@
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..eb0c2193 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 @@
//
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
// (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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
// 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 79bc1472..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 @@
// 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 @@
// 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 @@
// 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 @@
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..d2f4d1b5 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
virtual void Run() = 0;
};
-class BASE_API CancelableTask : public Task {
+class BASE_EXPORT CancelableTask : public Task {
public:
CancelableTask();
virtual ~CancelableTask();
@@ -550,7 +550,7 @@
// 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 45a43e91..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 @@
* 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 @@
//
// 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 @@
};
// 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 @@
// 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 @@
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 @@
// 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 @@
// (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 @@
//
// 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 b26568d6..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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 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..cfac6330 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 @@
// 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 @@
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..fc8ab4b52 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 @@
// 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 @@
// 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..7991c30d 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 58471b50..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 @@
// 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 @@
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..aa97f0ab 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 @@
// TimeDelta ------------------------------------------------------------------
-class BASE_API TimeDelta {
+class BASE_EXPORT TimeDelta {
public:
TimeDelta() : delta_(0) {
}
@@ -177,7 +177,7 @@
// 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 @@
// 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 @@
// TimeTicks ------------------------------------------------------------------
-class BASE_API TimeTicks {
+class BASE_EXPORT TimeTicks {
public:
TimeTicks() : ticks_(0) {
}
diff --git a/base/timer.h b/base/timer.h
index 6fe826a0..2e21582a 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 @@
//
// 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 @@
#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 @@
// 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 @@
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 @@
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 b6ab345b..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 @@
// 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 @@
//------------------------------------------------------------------------------
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// (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 @@
// (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 @@
// 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_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_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_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_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 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 @@
// 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..c65e6275 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 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 @@
// 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 @@
};
// 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 @@
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 @@
DISALLOW_COPY_AND_ASSIGN(StringValue);
};
-class BASE_API BinaryValue: public Value {
+class BASE_EXPORT BinaryValue: public Value {
public:
virtual ~BinaryValue();
@@ -214,7 +214,7 @@
// 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 @@
};
// 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 @@
// 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 b61cbb55..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 @@
// "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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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..66d7a06f 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 @@
// 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 16a52ec0..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 @@
// 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 847c434d..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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
// 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: