Remove base_export.h
This mucked up all the formatting alignment, but I'm going to leave it wrong in
this CL and then globally clang-format in the next one to keep the changes
separate.
Change-Id: I53c836a83d26edcae9b97831844f7a6b350cfd14
Reviewed-on: https://gn-review.googlesource.com/1624
Commit-Queue: Scott Graham <scottmg@chromium.org>
Reviewed-by: Brett Wilson <brettw@chromium.org>
diff --git a/base/base_export.h b/base/base_export.h
deleted file mode 100644
index cf7ebd7..0000000
--- a/base/base_export.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_BASE_EXPORT_H_
-#define BASE_BASE_EXPORT_H_
-
-#if defined(COMPONENT_BUILD)
-#if defined(WIN32)
-
-#if defined(BASE_IMPLEMENTATION)
-#define BASE_EXPORT __declspec(dllexport)
-#else
-#define BASE_EXPORT __declspec(dllimport)
-#endif // defined(BASE_IMPLEMENTATION)
-
-#else // defined(WIN32)
-#if defined(BASE_IMPLEMENTATION)
-#define BASE_EXPORT __attribute__((visibility("default")))
-#else
-#define BASE_EXPORT
-#endif // defined(BASE_IMPLEMENTATION)
-#endif
-
-#else // defined(COMPONENT_BUILD)
-#define BASE_EXPORT
-#endif
-
-#endif // BASE_BASE_EXPORT_H_
diff --git a/base/callback_internal.h b/base/callback_internal.h
index bfa5a6a..5139e6b 100644
--- a/base/callback_internal.h
+++ b/base/callback_internal.h
@@ -8,7 +8,6 @@
#ifndef BASE_CALLBACK_INTERNAL_H_
#define BASE_CALLBACK_INTERNAL_H_
-#include "base/base_export.h"
#include "base/callback_forward.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
@@ -58,7 +57,7 @@
// Creating a vtable for every BindState template instantiation results in a lot
// of bloat. Its only task is to call the destructor which can be done with a
// function pointer.
-class BASE_EXPORT BindStateBase
+class BindStateBase
: public RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits> {
public:
REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
@@ -106,7 +105,7 @@
// template bloat.
// CallbackBase<MoveOnly> is a direct base class of MoveOnly callbacks, and
// CallbackBase<Copyable> uses CallbackBase<MoveOnly> for its implementation.
-class BASE_EXPORT CallbackBase {
+class CallbackBase {
public:
CallbackBase(CallbackBase&& c) noexcept;
CallbackBase& operator=(CallbackBase&& c) noexcept;
@@ -155,7 +154,7 @@
constexpr CallbackBase::CallbackBase() = default;
// CallbackBase<Copyable> is a direct base class of Copyable Callbacks.
-class BASE_EXPORT CallbackBaseCopyable : public CallbackBase {
+class CallbackBaseCopyable : public CallbackBase {
public:
CallbackBaseCopyable(const CallbackBaseCopyable& c);
CallbackBaseCopyable(CallbackBaseCopyable&& c) noexcept;
diff --git a/base/command_line.h b/base/command_line.h
index f82ebfd..c8394ee 100644
--- a/base/command_line.h
+++ b/base/command_line.h
@@ -20,7 +20,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
#include "build_config.h"
@@ -29,7 +28,7 @@
class FilePath;
-class BASE_EXPORT CommandLine {
+class CommandLine {
public:
#if defined(OS_WIN)
// The native command line string type.
diff --git a/base/environment.h b/base/environment.h
index 5d05396..2d5976d 100644
--- a/base/environment.h
+++ b/base/environment.h
@@ -9,7 +9,6 @@
#include <memory>
#include <string>
-#include "base/base_export.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
#include "build_config.h"
@@ -19,12 +18,12 @@
namespace env_vars {
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-BASE_EXPORT extern const char kHome[];
+extern const char kHome[];
#endif
} // namespace env_vars
-class BASE_EXPORT Environment {
+class Environment {
public:
virtual ~Environment();
@@ -63,7 +62,7 @@
// which is a concatenated list of null-terminated 16-bit strings. The end is
// marked by a double-null terminator. The size of the returned string will
// include the terminators.
-BASE_EXPORT string16 AlterEnvironment(const wchar_t* env,
+string16 AlterEnvironment(const wchar_t* env,
const EnvironmentMap& changes);
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
@@ -79,7 +78,7 @@
// returned array will have appended to it the storage for the array itself so
// there is only one pointer to manage, but this means that you can't copy the
// array without keeping the original around.
-BASE_EXPORT std::unique_ptr<char* []> AlterEnvironment(
+std::unique_ptr<char* []> AlterEnvironment(
const char* const* env,
const EnvironmentMap& changes);
diff --git a/base/files/file.h b/base/files/file.h
index 3f959a4..c554249 100644
--- a/base/files/file.h
+++ b/base/files/file.h
@@ -9,7 +9,6 @@
#include <string>
-#include "base/base_export.h"
#include "base/files/file_path.h"
#include "base/files/platform_file.h"
#include "base/files/scoped_file.h"
@@ -40,7 +39,7 @@
// obvious non-modifying way are marked as const. Any method that forward calls
// to the OS is not considered const, even if there is no apparent change to
// member variables.
-class BASE_EXPORT File {
+class File {
public:
// FLAG_(OPEN|CREATE).* are mutually exclusive. You should specify exactly one
// of the five (possibly combining with other flags) when opening or creating
@@ -118,7 +117,7 @@
// make sure to update all functions that use it in file_util_{win|posix}.cc,
// too, and the ParamTraits<base::File::Info> implementation in
// ipc/ipc_message_utils.cc.
- struct BASE_EXPORT Info {
+ struct Info {
Info();
~Info();
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
diff --git a/base/files/file_enumerator.h b/base/files/file_enumerator.h
index db54301..45ce88b 100644
--- a/base/files/file_enumerator.h
+++ b/base/files/file_enumerator.h
@@ -10,7 +10,6 @@
#include <vector>
-#include "base/base_export.h"
#include "base/containers/stack.h"
#include "base/files/file_path.h"
#include "base/macros.h"
@@ -37,10 +36,10 @@
// FILE_PATH_LITERAL("*.txt"));
// for (base::FilePath name = enum.Next(); !name.empty(); name = enum.Next())
// ...
-class BASE_EXPORT FileEnumerator {
+class FileEnumerator {
public:
// Note: copy & assign supported.
- class BASE_EXPORT FileInfo {
+ class FileInfo {
public:
FileInfo();
~FileInfo();
diff --git a/base/files/file_path.h b/base/files/file_path.h
index be70317..8c153b4 100644
--- a/base/files/file_path.h
+++ b/base/files/file_path.h
@@ -108,7 +108,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/strings/string16.h"
@@ -140,7 +139,7 @@
// An abstraction to isolate users from the differences between native
// pathnames on different platforms.
-class BASE_EXPORT FilePath {
+class FilePath {
public:
#if defined(OS_WIN)
// On Windows, for Unicode-aware applications, native pathnames are wchar_t
@@ -438,7 +437,7 @@
StringType path_;
};
-BASE_EXPORT std::ostream& operator<<(std::ostream& out,
+std::ostream& operator<<(std::ostream& out,
const FilePath& file_path);
} // namespace base
diff --git a/base/files/file_util.h b/base/files/file_util.h
index d95410a..1401108 100644
--- a/base/files/file_util.h
+++ b/base/files/file_util.h
@@ -21,7 +21,6 @@
#include <unistd.h>
#endif
-#include "base/base_export.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/strings/string16.h"
@@ -45,14 +44,14 @@
// Returns an absolute version of a relative path. Returns an empty path on
// error. On POSIX, this function fails if the path does not exist. This
// function can result in I/O so it can be slow.
-BASE_EXPORT FilePath MakeAbsoluteFilePath(const FilePath& input);
+FilePath MakeAbsoluteFilePath(const FilePath& input);
// 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_EXPORT int64_t ComputeDirectorySize(const FilePath& root_path);
+int64_t ComputeDirectorySize(const FilePath& root_path);
// 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
@@ -66,7 +65,7 @@
//
// WARNING: USING THIS WITH recursive==true IS EQUIVALENT
// TO "rm -rf", SO USE WITH CAUTION.
-BASE_EXPORT bool DeleteFile(const FilePath& path, bool recursive);
+bool DeleteFile(const FilePath& path, bool recursive);
#if defined(OS_WIN)
// Schedules to delete the given path, whether it's a file or a directory, until
@@ -74,7 +73,7 @@
// Note:
// 1) The file/directory to be deleted should exist in a temp folder.
// 2) The directory to be deleted must be empty.
-BASE_EXPORT bool DeleteFileAfterReboot(const FilePath& path);
+bool DeleteFileAfterReboot(const FilePath& path);
#endif
// Moves the given path, whether it's a file or a directory.
@@ -82,7 +81,7 @@
// on different volumes, this will attempt to copy and delete. Returns
// true for success.
// This function fails if either path contains traversal components ('..').
-BASE_EXPORT bool Move(const FilePath& from_path, const FilePath& to_path);
+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
@@ -90,7 +89,7 @@
// temporary files. On Windows it preserves attributes of the target file.
// Returns true on success, leaving *error unchanged.
// Returns false on failure and sets *error appropriately, if it is non-NULL.
-BASE_EXPORT bool ReplaceFile(const FilePath& from_path,
+bool ReplaceFile(const FilePath& from_path,
const FilePath& to_path,
File::Error* error);
@@ -114,7 +113,7 @@
// Always 0600.
// - On ChromeOS, |to_path| has user read/write permissions and group/others
// read permissions. i.e. Always 0644.
-BASE_EXPORT bool CopyFile(const FilePath& from_path, const FilePath& to_path);
+bool CopyFile(const FilePath& from_path, const FilePath& to_path);
// Copies the given path, and optionally all subdirectories and their contents
// as well.
@@ -125,34 +124,34 @@
// This function has the same metadata behavior as CopyFile().
//
// If you only need to copy a file use CopyFile, it's faster.
-BASE_EXPORT bool CopyDirectory(const FilePath& from_path,
+bool CopyDirectory(const FilePath& from_path,
const FilePath& to_path,
bool recursive);
// Like CopyDirectory() except trying to overwrite an existing file will not
// work and will return false.
-BASE_EXPORT bool CopyDirectoryExcl(const FilePath& from_path,
+bool CopyDirectoryExcl(const FilePath& from_path,
const FilePath& to_path,
bool recursive);
// Returns true if the given path exists on the local filesystem,
// false otherwise.
-BASE_EXPORT bool PathExists(const FilePath& path);
+bool PathExists(const FilePath& path);
// Returns true if the given path is writable by the user, false otherwise.
-BASE_EXPORT bool PathIsWritable(const FilePath& path);
+bool PathIsWritable(const FilePath& path);
// Returns true if the given path exists and is a directory, false otherwise.
-BASE_EXPORT bool DirectoryExists(const FilePath& path);
+bool DirectoryExists(const FilePath& path);
// Returns true if the contents of the two files given are equal, false
// otherwise. If either file can't be read, returns false.
-BASE_EXPORT bool ContentsEqual(const FilePath& filename1,
+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_EXPORT bool TextContentsEqual(const FilePath& filename1,
+bool TextContentsEqual(const FilePath& filename1,
const FilePath& filename2);
// Reads the file at |path| into |contents| and returns true on success and
@@ -162,7 +161,7 @@
// file before the error occurred.
// |contents| may be NULL, in which case this function is useful for its side
// effect of priming the disk cache (could be used for unit tests).
-BASE_EXPORT bool ReadFileToString(const FilePath& path, std::string* contents);
+bool ReadFileToString(const FilePath& path, std::string* contents);
// Reads the file at |path| into |contents| and returns true on success and
// false on error. For security reasons, a |path| containing path traversal
@@ -173,7 +172,7 @@
// |max_size|.
// |contents| may be NULL, in which case this function is useful for its side
// effect of priming the disk cache (could be used for unit tests).
-BASE_EXPORT bool ReadFileToStringWithMaxSize(const FilePath& path,
+bool ReadFileToStringWithMaxSize(const FilePath& path,
std::string* contents,
size_t max_size);
@@ -182,12 +181,12 @@
// 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 successfully read from |fd|.
-BASE_EXPORT bool ReadFromFD(int fd, char* buffer, size_t bytes);
+bool ReadFromFD(int fd, char* buffer, size_t bytes);
// Performs the same function as CreateAndOpenTemporaryFileInDir(), but returns
// the file-descriptor directly, rather than wrapping it into a FILE. Returns
// -1 on failure.
-BASE_EXPORT int CreateAndOpenFdForTemporaryFileInDir(const FilePath& dir,
+int CreateAndOpenFdForTemporaryFileInDir(const FilePath& dir,
FilePath* path);
#endif // OS_POSIX || OS_FUCHSIA
@@ -196,12 +195,12 @@
// Creates a symbolic link at |symlink| pointing to |target|. Returns
// false on failure.
-BASE_EXPORT bool CreateSymbolicLink(const FilePath& target,
+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_EXPORT bool ReadSymbolicLink(const FilePath& symlink, FilePath* target);
+bool ReadSymbolicLink(const FilePath& symlink, FilePath* target);
// Bits and masks of the file permission.
enum FilePermissionBits {
@@ -224,20 +223,20 @@
// Reads the permission of the given |path|, storing the file permission
// bits in |mode|. If |path| is symbolic link, |mode| is the permission of
// a file which the symlink points to.
-BASE_EXPORT bool GetPosixFilePermissions(const FilePath& path, int* mode);
+bool GetPosixFilePermissions(const FilePath& path, int* mode);
// Sets the permission of the given |path|. If |path| is symbolic link, sets
// the permission of a file which the symlink points to.
-BASE_EXPORT bool SetPosixFilePermissions(const FilePath& path, int mode);
+bool SetPosixFilePermissions(const FilePath& path, int mode);
// Returns true iff |executable| can be found in any directory specified by the
// environment variable in |env|.
-BASE_EXPORT bool ExecutableExistsInPath(Environment* env,
+bool ExecutableExistsInPath(Environment* env,
const FilePath::StringType& executable);
#endif // OS_POSIX
// Returns true if the given directory is empty
-BASE_EXPORT bool IsDirectoryEmpty(const FilePath& dir_path);
+bool IsDirectoryEmpty(const FilePath& dir_path);
// Get the temporary directory provided by the system.
//
@@ -245,7 +244,7 @@
// instead of this function. Those variants will ensure that the proper
// permissions are set so that other users on the system can't edit them while
// they're open (which can lead to security issues).
-BASE_EXPORT bool GetTempDir(FilePath* path);
+bool GetTempDir(FilePath* path);
// Get the home directory. This is more complicated than just getenv("HOME")
// as it knows to fall back on getpwent() etc.
@@ -253,37 +252,37 @@
// You should not generally call this directly. Instead use DIR_HOME with the
// path service which will use this function but cache the value.
// Path service may also override DIR_HOME.
-BASE_EXPORT FilePath GetHomeDir();
+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_EXPORT bool CreateTemporaryFile(FilePath* path);
+bool CreateTemporaryFile(FilePath* path);
// Same as CreateTemporaryFile but the file is created in |dir|.
-BASE_EXPORT bool CreateTemporaryFileInDir(const FilePath& dir,
+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 occurred.
-BASE_EXPORT FILE* CreateAndOpenTemporaryFile(FilePath* path);
+FILE* CreateAndOpenTemporaryFile(FilePath* path);
// Similar to CreateAndOpenTemporaryFile, but the file is created in |dir|.
-BASE_EXPORT FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir,
+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_EXPORT bool CreateNewTempDirectory(const FilePath::StringType& prefix,
+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_EXPORT bool CreateTemporaryDirInDir(const FilePath& base_dir,
+bool CreateTemporaryDirInDir(const FilePath& base_dir,
const FilePath::StringType& prefix,
FilePath* new_dir);
@@ -292,14 +291,14 @@
// already exists. The directory is only readable by the current user.
// Returns true on success, leaving *error unchanged.
// Returns false on failure and sets *error appropriately, if it is non-NULL.
-BASE_EXPORT bool CreateDirectoryAndGetError(const FilePath& full_path,
+bool CreateDirectoryAndGetError(const FilePath& full_path,
File::Error* error);
// Backward-compatible convenience method for the above.
-BASE_EXPORT bool CreateDirectory(const FilePath& full_path);
+bool CreateDirectory(const FilePath& full_path);
// Returns the file size. Returns true on success.
-BASE_EXPORT bool GetFileSize(const FilePath& file_path, int64_t* file_size);
+bool GetFileSize(const FilePath& file_path, int64_t* file_size);
// Sets |real_path| to |path| with symbolic links and junctions expanded.
// On windows, make sure the path starts with a lettered drive.
@@ -307,101 +306,101 @@
// 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_EXPORT bool NormalizeFilePath(const FilePath& path, FilePath* real_path);
+bool NormalizeFilePath(const FilePath& path, FilePath* real_path);
#if defined(OS_WIN)
// Given a path in NT native form ("\Device\HarddiskVolumeXX\..."),
// return in |drive_letter_path| the equivalent path that starts with
// a drive letter ("C:\..."). Return false if no such path exists.
-BASE_EXPORT bool DevicePathToDriveLetterPath(const FilePath& device_path,
+bool DevicePathToDriveLetterPath(const FilePath& device_path,
FilePath* drive_letter_path);
// Given an existing file in |path|, set |real_path| to the path
// in native NT format, of the form "\Device\HarddiskVolumeXX\..".
// Returns false if the path can not be found. Empty files cannot
// be resolved with this function.
-BASE_EXPORT bool NormalizeToNativeFilePath(const FilePath& path,
+bool NormalizeToNativeFilePath(const FilePath& path,
FilePath* nt_path);
#endif
// This function will return if the given file is a symlink or not.
-BASE_EXPORT bool IsLink(const FilePath& file_path);
+bool IsLink(const FilePath& file_path);
// Returns information about the given file path.
-BASE_EXPORT bool GetFileInfo(const FilePath& file_path, File::Info* info);
+bool GetFileInfo(const FilePath& file_path, File::Info* info);
// Sets the time of the last access and the time of the last modification.
-BASE_EXPORT bool TouchFile(const FilePath& path,
+bool TouchFile(const FilePath& path,
const Time& last_accessed,
const Time& last_modified);
// Wrapper for fopen-like calls. Returns non-NULL FILE* on success. The
// underlying file descriptor (POSIX) or handle (Windows) is unconditionally
// configured to not be propagated to child processes.
-BASE_EXPORT FILE* OpenFile(const FilePath& filename, const char* mode);
+FILE* OpenFile(const FilePath& filename, const char* mode);
// Closes file opened by OpenFile. Returns true on success.
-BASE_EXPORT bool CloseFile(FILE* file);
+bool CloseFile(FILE* file);
// Associates a standard FILE stream with an existing File. Note that this
// functions take ownership of the existing File.
-BASE_EXPORT FILE* FileToFILE(File file, const char* mode);
+FILE* FileToFILE(File file, const char* mode);
// 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_EXPORT bool TruncateFile(FILE* file);
+bool TruncateFile(FILE* file);
// Reads at most the given number of bytes from the file into the buffer.
// Returns the number of read bytes, or -1 on error.
-BASE_EXPORT int ReadFile(const FilePath& filename, char* data, int max_size);
+int ReadFile(const FilePath& filename, char* data, int max_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_EXPORT int WriteFile(const FilePath& filename, const char* data,
+int WriteFile(const FilePath& filename, const char* data,
int size);
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
// Appends |data| to |fd|. Does not close |fd| when done. Returns true iff
// |size| bytes of |data| were written to |fd|.
-BASE_EXPORT bool WriteFileDescriptor(const int fd, const char* data, int size);
+bool WriteFileDescriptor(const int fd, const char* data, int size);
#endif
// Appends |data| to |filename|. Returns true iff |size| bytes of |data| were
// written to |filename|.
-BASE_EXPORT bool AppendToFile(const FilePath& filename,
+bool AppendToFile(const FilePath& filename,
const char* data,
int size);
// Gets the current working directory for the process.
-BASE_EXPORT bool GetCurrentDirectory(FilePath* path);
+bool GetCurrentDirectory(FilePath* path);
// Sets the current working directory for the process.
-BASE_EXPORT bool SetCurrentDirectory(const FilePath& path);
+bool SetCurrentDirectory(const FilePath& path);
// Attempts to find a number that can be appended to the |path| to make it
// unique. If |path| does not exist, 0 is returned. If it fails to find such
// a number, -1 is returned. If |suffix| is not empty, also checks the
// existence of it with the given suffix.
-BASE_EXPORT int GetUniquePathNumber(const FilePath& path,
+int GetUniquePathNumber(const FilePath& path,
const FilePath::StringType& suffix);
// Sets the given |fd| to non-blocking mode.
// Returns true if it was able to set it in the non-blocking mode, otherwise
// false.
-BASE_EXPORT bool SetNonBlocking(int fd);
+bool SetNonBlocking(int fd);
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
// Creates a non-blocking, close-on-exec pipe.
// This creates a non-blocking pipe that is not intended to be shared with any
// child process. This will be done atomically if the operating system supports
// it. Returns true if it was able to create the pipe, otherwise false.
-BASE_EXPORT bool CreateLocalNonBlockingPipe(int fds[2]);
+bool CreateLocalNonBlockingPipe(int fds[2]);
// Sets the given |fd| to close-on-exec mode.
// Returns true if it was able to set it in the close-on-exec mode, otherwise
// false.
-BASE_EXPORT bool SetCloseOnExec(int fd);
+bool SetCloseOnExec(int fd);
// Test that |path| can only be changed by a given user and members of
// a given set of groups.
@@ -414,7 +413,7 @@
// * Are not symbolic links.
// This is useful for checking that a config file is administrator-controlled.
// |base| must contain |path|.
-BASE_EXPORT bool VerifyPathControlledByUser(const base::FilePath& base,
+bool VerifyPathControlledByUser(const base::FilePath& base,
const base::FilePath& path,
uid_t owner_uid,
const std::set<gid_t>& group_gids);
@@ -428,12 +427,12 @@
// the filesystem, are owned by the superuser, controlled by the group
// "admin", are not writable by all users, and contain no symbolic links.
// Will return false if |path| does not exist.
-BASE_EXPORT bool VerifyPathControlledByAdmin(const base::FilePath& path);
+bool VerifyPathControlledByAdmin(const base::FilePath& path);
#endif // defined(OS_MACOSX) && !defined(OS_IOS)
// Returns the maximum length of path component on the volume containing
// the directory |path|, in the number of FilePath::CharType, or -1 on failure.
-BASE_EXPORT int GetMaximumPathComponentLength(const base::FilePath& path);
+int GetMaximumPathComponentLength(const base::FilePath& path);
#if defined(OS_LINUX) || defined(OS_AIX)
// Broad categories of file systems as returned by statfs() on Linux.
@@ -452,7 +451,7 @@
// Attempts determine the FileSystemType for |path|.
// Returns false if |path| doesn't exist.
-BASE_EXPORT bool GetFileSystemType(const FilePath& path, FileSystemType* type);
+bool GetFileSystemType(const FilePath& path, FileSystemType* type);
#endif
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
@@ -461,7 +460,7 @@
// depends on how /dev/shmem was mounted. As a result, you must supply whether
// you intend to create executable shmem segments so this function can find
// an appropriate location.
-BASE_EXPORT bool GetShmemTempDir(bool executable, FilePath* path);
+bool GetShmemTempDir(bool executable, FilePath* path);
#endif
// Internal --------------------------------------------------------------------
@@ -470,7 +469,7 @@
// Same as Move but allows paths with traversal components.
// Use only with extreme care.
-BASE_EXPORT bool MoveUnsafe(const FilePath& from_path,
+bool MoveUnsafe(const FilePath& from_path,
const FilePath& to_path);
#if defined(OS_WIN)
@@ -478,7 +477,7 @@
// Returns true if all operations succeed.
// This function simulates Move(), but unlike Move() it works across volumes.
// This function is not transactional.
-BASE_EXPORT bool CopyAndDeleteDirectory(const FilePath& from_path,
+bool CopyAndDeleteDirectory(const FilePath& from_path,
const FilePath& to_path);
#endif // defined(OS_WIN)
diff --git a/base/files/scoped_file.h b/base/files/scoped_file.h
index ee8ed8b..c1a2988 100644
--- a/base/files/scoped_file.h
+++ b/base/files/scoped_file.h
@@ -9,7 +9,6 @@
#include <memory>
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/scoped_generic.h"
#include "build_config.h"
@@ -19,7 +18,7 @@
namespace internal {
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-struct BASE_EXPORT ScopedFDCloseTraits {
+struct ScopedFDCloseTraits {
static int InvalidValue() {
return -1;
}
diff --git a/base/files/scoped_temp_dir.h b/base/files/scoped_temp_dir.h
index 872f6f8..4ddb690 100644
--- a/base/files/scoped_temp_dir.h
+++ b/base/files/scoped_temp_dir.h
@@ -17,13 +17,12 @@
// (CreateUniqueTempDir, CreateUniqueTempDirUnderPath, and Set) must have
// intervening calls to Delete or Take, or the calls will fail.
-#include "base/base_export.h"
#include "base/files/file_path.h"
#include "base/macros.h"
namespace base {
-class BASE_EXPORT ScopedTempDir {
+class ScopedTempDir {
public:
// No directory is owned/created initially.
ScopedTempDir();
diff --git a/base/json/json_file_value_serializer.h b/base/json/json_file_value_serializer.h
index a93950a..db243b7 100644
--- a/base/json/json_file_value_serializer.h
+++ b/base/json/json_file_value_serializer.h
@@ -9,12 +9,11 @@
#include <string>
-#include "base/base_export.h"
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/values.h"
-class BASE_EXPORT JSONFileValueSerializer : public base::ValueSerializer {
+class JSONFileValueSerializer : public base::ValueSerializer {
public:
// |json_file_path_| is the path of a file that will be destination of the
// serialization. The serializer will attempt to create the file at the
@@ -45,7 +44,7 @@
DISALLOW_IMPLICIT_CONSTRUCTORS(JSONFileValueSerializer);
};
-class BASE_EXPORT JSONFileValueDeserializer : public base::ValueDeserializer {
+class JSONFileValueDeserializer : public base::ValueDeserializer {
public:
// |json_file_path_| is the path of a file that will be source of the
// deserialization. |options| is a bitmask of JSONParserOptions.
diff --git a/base/json/json_parser.h b/base/json/json_parser.h
index a4dd2ba..b14a8d7 100644
--- a/base/json/json_parser.h
+++ b/base/json/json_parser.h
@@ -11,7 +11,6 @@
#include <memory>
#include <string>
-#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/gtest_prod_util.h"
#include "base/json/json_reader.h"
@@ -41,7 +40,7 @@
// to the first byte of a valid JSON token. On exit, it is on the first byte
// after the token that was just consumed, which would likely be the first byte
// of the next token.
-class BASE_EXPORT JSONParser {
+class JSONParser {
public:
JSONParser(int options, int max_depth = JSONReader::kStackMaxDepth);
~JSONParser();
@@ -252,7 +251,7 @@
};
// Used when decoding and an invalid utf-8 sequence is encountered.
-BASE_EXPORT extern const char kUnicodeReplacementString[];
+extern const char kUnicodeReplacementString[];
} // namespace internal
} // namespace base
diff --git a/base/json/json_reader.h b/base/json/json_reader.h
index 2c6bd3e..c4f7c8f 100644
--- a/base/json/json_reader.h
+++ b/base/json/json_reader.h
@@ -31,7 +31,6 @@
#include <memory>
#include <string>
-#include "base/base_export.h"
#include "base/strings/string_piece.h"
namespace base {
@@ -56,7 +55,7 @@
JSON_REPLACE_INVALID_CHARACTERS = 1 << 1,
};
-class BASE_EXPORT JSONReader {
+class JSONReader {
public:
static const int kStackMaxDepth;
diff --git a/base/json/json_string_value_serializer.h b/base/json/json_string_value_serializer.h
index 55a53e2..1a34484 100644
--- a/base/json/json_string_value_serializer.h
+++ b/base/json/json_string_value_serializer.h
@@ -7,13 +7,12 @@
#include <string>
-#include "base/base_export.h"
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/strings/string_piece.h"
#include "base/values.h"
-class BASE_EXPORT JSONStringValueSerializer : public base::ValueSerializer {
+class JSONStringValueSerializer : public base::ValueSerializer {
public:
// |json_string| is the string that will be the destination of the
// serialization. The caller of the constructor retains ownership of the
@@ -44,7 +43,7 @@
DISALLOW_COPY_AND_ASSIGN(JSONStringValueSerializer);
};
-class BASE_EXPORT JSONStringValueDeserializer : public base::ValueDeserializer {
+class JSONStringValueDeserializer : public base::ValueDeserializer {
public:
// This retains a reference to the contents of |json_string|, so the data
// must outlive the JSONStringValueDeserializer. |options| is a bitmask of
diff --git a/base/json/json_value_converter.h b/base/json/json_value_converter.h
index 2e677c6..115e47a 100644
--- a/base/json/json_value_converter.h
+++ b/base/json/json_value_converter.h
@@ -11,7 +11,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
@@ -138,7 +137,7 @@
class BasicValueConverter;
template <>
-class BASE_EXPORT BasicValueConverter<int> : public ValueConverter<int> {
+class BasicValueConverter<int> : public ValueConverter<int> {
public:
BasicValueConverter() = default;
@@ -149,7 +148,7 @@
};
template <>
-class BASE_EXPORT BasicValueConverter<std::string>
+class BasicValueConverter<std::string>
: public ValueConverter<std::string> {
public:
BasicValueConverter() = default;
@@ -161,7 +160,7 @@
};
template <>
-class BASE_EXPORT BasicValueConverter<string16>
+class BasicValueConverter<string16>
: public ValueConverter<string16> {
public:
BasicValueConverter() = default;
@@ -173,7 +172,7 @@
};
template <>
-class BASE_EXPORT BasicValueConverter<double> : public ValueConverter<double> {
+class BasicValueConverter<double> : public ValueConverter<double> {
public:
BasicValueConverter() = default;
@@ -184,7 +183,7 @@
};
template <>
-class BASE_EXPORT BasicValueConverter<bool> : public ValueConverter<bool> {
+class BasicValueConverter<bool> : public ValueConverter<bool> {
public:
BasicValueConverter() = default;
diff --git a/base/json/json_writer.h b/base/json/json_writer.h
index 57cb8c1..7edd3a6 100644
--- a/base/json/json_writer.h
+++ b/base/json/json_writer.h
@@ -9,14 +9,13 @@
#include <string>
-#include "base/base_export.h"
#include "base/macros.h"
namespace base {
class Value;
-class BASE_EXPORT JSONWriter {
+class JSONWriter {
public:
enum Options {
// This option instructs the writer that if a Binary value is encountered,
diff --git a/base/json/string_escape.h b/base/json/string_escape.h
index f75f475..2f74836 100644
--- a/base/json/string_escape.h
+++ b/base/json/string_escape.h
@@ -9,7 +9,6 @@
#include <string>
-#include "base/base_export.h"
#include "base/strings/string_piece.h"
namespace base {
@@ -26,21 +25,21 @@
//
// If |put_in_quotes| is true, then a leading and trailing double-quote mark
// will be appended to |dest| as well.
-BASE_EXPORT bool EscapeJSONString(StringPiece str,
+bool EscapeJSONString(StringPiece str,
bool put_in_quotes,
std::string* dest);
// Performs a similar function to the UTF-8 StringPiece version above,
// converting UTF-16 code units to UTF-8 code units and escaping non-printing
// control characters. On return, |dest| will contain a valid UTF-8 JSON string.
-BASE_EXPORT bool EscapeJSONString(StringPiece16 str,
+bool EscapeJSONString(StringPiece16 str,
bool put_in_quotes,
std::string* dest);
// Helper functions that wrap the above two functions but return the value
// instead of appending. |put_in_quotes| is always true.
-BASE_EXPORT std::string GetQuotedJSONString(StringPiece str);
-BASE_EXPORT std::string GetQuotedJSONString(StringPiece16 str);
+std::string GetQuotedJSONString(StringPiece str);
+std::string GetQuotedJSONString(StringPiece16 str);
// Given an arbitrary byte string |str|, this will escape all non-ASCII bytes
// as \uXXXX escape sequences. This function is *NOT* meant to be used with
@@ -53,7 +52,7 @@
//
// The output of this function takes the *appearance* of JSON but is not in
// fact valid according to RFC 4627.
-BASE_EXPORT std::string EscapeBytesAsInvalidJSONString(StringPiece str,
+std::string EscapeBytesAsInvalidJSONString(StringPiece str,
bool put_in_quotes);
} // namespace base
diff --git a/base/logging.cc b/base/logging.cc
index aacc90c..915f2e0 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -345,7 +345,7 @@
// In DCHECK-enabled Chrome builds, allow the meaning of LOG_DCHECK to be
// determined at run-time. We default it to INFO, to avoid it triggering
// crashes before the run-time has explicitly chosen the behaviour.
-BASE_EXPORT logging::LogSeverity LOG_DCHECK = LOG_INFO;
+logging::LogSeverity LOG_DCHECK = LOG_INFO;
#endif // DCHECK_IS_CONFIGURABLE
// This is never instantiated, it's just used for EAT_STREAM_PARAMETERS to have
@@ -799,7 +799,7 @@
#endif
}
-BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code) {
+std::string SystemErrorCodeToString(SystemErrorCode error_code) {
#if defined(OS_WIN)
const int kErrorMessageBufferSize = 256;
char msgbuf[kErrorMessageBufferSize];
@@ -899,7 +899,7 @@
}
#endif
-BASE_EXPORT void LogErrorNotReached(const char* file, int line) {
+void LogErrorNotReached(const char* file, int line) {
LogMessage(file, line, LOG_ERROR).stream()
<< "NOTREACHED() hit.";
}
diff --git a/base/logging.h b/base/logging.h
index 13c30ab..36eb271 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -14,7 +14,6 @@
#include <type_traits>
#include <utility>
-#include "base/base_export.h"
#include "base/callback_forward.h"
#include "base/compiler_specific.h"
#include "base/macros.h"
@@ -144,7 +143,7 @@
// Defaults to APPEND_TO_OLD_LOG_FILE.
enum OldFileDeletionState { DELETE_OLD_LOG_FILE, APPEND_TO_OLD_LOG_FILE };
-struct BASE_EXPORT LoggingSettings {
+struct LoggingSettings {
// The defaults values are:
//
// logging_dest: LOG_DEFAULT
@@ -175,7 +174,7 @@
// 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_EXPORT bool BaseInitLoggingImpl(const LoggingSettings& settings);
+bool BaseInitLoggingImpl(const LoggingSettings& settings);
// 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.
@@ -199,25 +198,25 @@
// log file/displayed to the user (if applicable). Anything below this level
// will be silently ignored. The log level defaults to 0 (everything is logged
// up to level INFO) if this function is not called.
-BASE_EXPORT void SetMinLogLevel(int level);
+void SetMinLogLevel(int level);
// Gets the current log level.
-BASE_EXPORT int GetMinLogLevel();
+int GetMinLogLevel();
// Used by LOG_IS_ON to lazy-evaluate stream arguments.
-BASE_EXPORT bool ShouldCreateLogMessage(int severity);
+bool ShouldCreateLogMessage(int severity);
// Sets the common items you want to be prepended to each log message.
// 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_EXPORT void SetLogItems(bool enable_process_id, bool enable_thread_id,
+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_EXPORT void SetShowErrorDialogs(bool enable_dialogs);
+void SetShowErrorDialogs(bool enable_dialogs);
// Sets the Log Message Handler that gets passed every log message before
// it's sent to other log destinations (if any).
@@ -225,8 +224,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_EXPORT void SetLogMessageHandler(LogMessageHandlerFunction handler);
-BASE_EXPORT LogMessageHandlerFunction GetLogMessageHandler();
+void SetLogMessageHandler(LogMessageHandlerFunction handler);
+LogMessageHandlerFunction GetLogMessageHandler();
// The ANALYZER_ASSUME_TRUE(bool arg) macro adds compiler-specific hints
// to Clang which control what code paths are statically analyzed,
@@ -360,7 +359,7 @@
#define PLOG_IF(severity, condition) \
LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
-BASE_EXPORT extern std::ostream* g_swallow_stream;
+extern std::ostream* g_swallow_stream;
// Note that g_swallow_stream is used instead of an arbitrary LOG() stream to
// avoid the creation of an object with a non-trivial destructor (LogMessage).
@@ -606,7 +605,7 @@
}
// We need an explicit overload for std::nullptr_t.
-BASE_EXPORT void MakeCheckOpValueString(std::ostream* os, std::nullptr_t p);
+void MakeCheckOpValueString(std::ostream* os, std::nullptr_t p);
// Build the error message string. This is separate from the "Impl"
// function template because it is not performance critical and so can
@@ -626,18 +625,18 @@
// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
// in logging.cc.
-extern template BASE_EXPORT std::string* MakeCheckOpString<int, int>(
+extern template std::string* MakeCheckOpString<int, int>(
const int&, const int&, const char* names);
-extern template BASE_EXPORT
+extern template
std::string* MakeCheckOpString<unsigned long, unsigned long>(
const unsigned long&, const unsigned long&, const char* names);
-extern template BASE_EXPORT
+extern template
std::string* MakeCheckOpString<unsigned long, unsigned int>(
const unsigned long&, const unsigned int&, const char* names);
-extern template BASE_EXPORT
+extern template
std::string* MakeCheckOpString<unsigned int, unsigned long>(
const unsigned int&, const unsigned long&, const char* names);
-extern template BASE_EXPORT
+extern template
std::string* MakeCheckOpString<std::string, std::string>(
const std::string&, const std::string&, const char* name);
@@ -718,7 +717,7 @@
#if DCHECK_IS_ON()
#if DCHECK_IS_CONFIGURABLE
-BASE_EXPORT extern LogSeverity LOG_DCHECK;
+extern LogSeverity LOG_DCHECK;
#else
const LogSeverity LOG_DCHECK = LOG_FATAL;
#endif
@@ -861,7 +860,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_EXPORT LogMessage {
+class LogMessage {
public:
// Used for LOG(severity).
LogMessage(const char* file, int line, LogSeverity severity);
@@ -937,12 +936,12 @@
// Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to
// pull in windows.h just for GetLastError() and DWORD.
-BASE_EXPORT SystemErrorCode GetLastSystemErrorCode();
-BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code);
+SystemErrorCode GetLastSystemErrorCode();
+std::string SystemErrorCodeToString(SystemErrorCode error_code);
#if defined(OS_WIN)
// Appends a formatted system message of the GetLastError() type.
-class BASE_EXPORT Win32ErrorLogMessage {
+class Win32ErrorLogMessage {
public:
Win32ErrorLogMessage(const char* file,
int line,
@@ -962,7 +961,7 @@
};
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
// Appends a formatted system message of the errno type
-class BASE_EXPORT ErrnoLogMessage {
+class ErrnoLogMessage {
public:
ErrnoLogMessage(const char* file,
int line,
@@ -986,10 +985,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_EXPORT void CloseLogFile();
+void CloseLogFile();
// Async signal safe logging mechanism.
-BASE_EXPORT void RawLog(int level, const char* message);
+void RawLog(int level, const char* message);
#define RAW_LOG(level, message) \
::logging::RawLog(::logging::LOG_##level, message)
@@ -1003,10 +1002,10 @@
#if defined(OS_WIN)
// Returns true if logging to file is enabled.
-BASE_EXPORT bool IsLoggingToFileEnabled();
+bool IsLoggingToFileEnabled();
// Returns the default log file path.
-BASE_EXPORT std::wstring GetLogFileFullPath();
+std::wstring GetLogFileFullPath();
#endif
} // namespace logging
@@ -1026,7 +1025,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_EXPORT std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
+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();
}
diff --git a/base/mac/bundle_locations.h b/base/mac/bundle_locations.h
index 5cc44ba..86ff1a4 100644
--- a/base/mac/bundle_locations.h
+++ b/base/mac/bundle_locations.h
@@ -5,7 +5,6 @@
#ifndef BASE_MAC_BUNDLE_LOCATIONS_H_
#define BASE_MAC_BUNDLE_LOCATIONS_H_
-#include "base/base_export.h"
#include "base/files/file_path.h"
#if defined(__OBJC__)
@@ -44,21 +43,21 @@
// bundle is probably the one to use.
// Methods for retrieving the various bundles.
-BASE_EXPORT NSBundle* MainBundle();
-BASE_EXPORT FilePath MainBundlePath();
-BASE_EXPORT NSBundle* OuterBundle();
-BASE_EXPORT FilePath OuterBundlePath();
-BASE_EXPORT NSBundle* FrameworkBundle();
-BASE_EXPORT FilePath FrameworkBundlePath();
+NSBundle* MainBundle();
+FilePath MainBundlePath();
+NSBundle* OuterBundle();
+FilePath OuterBundlePath();
+NSBundle* FrameworkBundle();
+FilePath FrameworkBundlePath();
// Set the bundle that the preceding functions will return, overriding the
// default values. Restore the default by passing in |nil|.
-BASE_EXPORT void SetOverrideOuterBundle(NSBundle* bundle);
-BASE_EXPORT void SetOverrideFrameworkBundle(NSBundle* bundle);
+void SetOverrideOuterBundle(NSBundle* bundle);
+void SetOverrideFrameworkBundle(NSBundle* bundle);
// Same as above but accepting a FilePath argument.
-BASE_EXPORT void SetOverrideOuterBundlePath(const FilePath& file_path);
-BASE_EXPORT void SetOverrideFrameworkBundlePath(const FilePath& file_path);
+void SetOverrideOuterBundlePath(const FilePath& file_path);
+void SetOverrideFrameworkBundlePath(const FilePath& file_path);
} // namespace mac
} // namespace base
diff --git a/base/mac/dispatch_source_mach.h b/base/mac/dispatch_source_mach.h
index 336125f..84af3b3 100644
--- a/base/mac/dispatch_source_mach.h
+++ b/base/mac/dispatch_source_mach.h
@@ -7,7 +7,6 @@
#include <dispatch/dispatch.h>
-#include "base/base_export.h"
#include "base/mac/scoped_dispatch_object.h"
#include "base/macros.h"
@@ -17,7 +16,7 @@
// destroyed, the source will be cancelled and it will wait for the source
// to stop executing work. The source can run on either a user-supplied queue,
// or it can create its own for the source.
-class BASE_EXPORT DispatchSourceMach {
+class DispatchSourceMach {
public:
// Creates a new dispatch source for the |port| and schedules it on a new
// queue that will be created with |name|. When a Mach message is received,
diff --git a/base/mac/foundation_util.h b/base/mac/foundation_util.h
index d92a204..29f281b 100644
--- a/base/mac/foundation_util.h
+++ b/base/mac/foundation_util.h
@@ -10,7 +10,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/mac/scoped_cftyperef.h"
#include "build_config.h"
@@ -70,8 +69,8 @@
namespace mac {
// Returns true if the application is running from a bundle
-BASE_EXPORT bool AmIBundled();
-BASE_EXPORT void SetOverrideAmIBundled(bool value);
+bool AmIBundled();
+void SetOverrideAmIBundled(bool value);
#if defined(UNIT_TEST)
// This is required because instantiating some tests requires checking the
@@ -79,14 +78,14 @@
// may or may not be bundled, and this would trip them up if the cache weren't
// cleared. This should not be called from individual tests, just from test
// instantiation code that gets a path from PathService.
-BASE_EXPORT void ClearAmIBundledCache();
+void ClearAmIBundledCache();
#endif
// Returns true if this process is marked as a "Background only process".
-BASE_EXPORT bool IsBackgroundOnlyProcess();
+bool IsBackgroundOnlyProcess();
// Returns the path to a resource within the framework bundle.
-BASE_EXPORT FilePath PathForFrameworkBundleResource(CFStringRef resourceName);
+FilePath PathForFrameworkBundleResource(CFStringRef resourceName);
// Returns the creator code associated with the CFBundleRef at bundle.
OSType CreatorCodeForCFBundleRef(CFBundleRef bundle);
@@ -97,39 +96,39 @@
// 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_EXPORT OSType CreatorCodeForApplication();
+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
// first found directory and returns true. Otherwise, returns false.
-BASE_EXPORT bool GetSearchPathDirectory(NSSearchPathDirectory directory,
+bool GetSearchPathDirectory(NSSearchPathDirectory directory,
NSSearchPathDomainMask domain_mask,
FilePath* result);
// 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_EXPORT bool GetLocalDirectory(NSSearchPathDirectory directory,
+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_EXPORT bool GetUserDirectory(NSSearchPathDirectory directory,
+bool GetUserDirectory(NSSearchPathDirectory directory,
FilePath* result);
// Returns the ~/Library directory.
-BASE_EXPORT FilePath GetUserLibraryPath();
+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_EXPORT FilePath GetAppBundlePath(const FilePath& exec_name);
+FilePath GetAppBundlePath(const FilePath& exec_name);
#define TYPE_NAME_FOR_CF_TYPE_DECL(TypeCF) \
-BASE_EXPORT std::string TypeNameForCFType(TypeCF##Ref);
+std::string TypeNameForCFType(TypeCF##Ref);
TYPE_NAME_FOR_CF_TYPE_DECL(CFArray);
TYPE_NAME_FOR_CF_TYPE_DECL(CFBag);
@@ -155,8 +154,8 @@
#undef TYPE_NAME_FOR_CF_TYPE_DECL
// Retain/release calls for memory management in C++.
-BASE_EXPORT void NSObjectRetain(void* obj);
-BASE_EXPORT void NSObjectRelease(void* obj);
+void NSObjectRetain(void* obj);
+void NSObjectRelease(void* obj);
// CFTypeRefToNSObjectAutorelease transfers ownership of a Core Foundation
// object (one derived from CFTypeRef) to the Foundation memory management
@@ -175,16 +174,16 @@
// returned NSObject.
//
// Returns an id, typed here for C++'s sake as a void*.
-BASE_EXPORT void* CFTypeRefToNSObjectAutorelease(CFTypeRef cf_object);
+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_EXPORT const char* BaseBundleID();
+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_EXPORT void SetBaseBundleID(const char* new_base_bundle_id);
+void SetBaseBundleID(const char* new_base_bundle_id);
} // namespace mac
} // namespace base
@@ -213,8 +212,8 @@
\
namespace base { \
namespace mac { \
-BASE_EXPORT TypeNS* CFToNSCast(TypeCF##Ref cf_val); \
-BASE_EXPORT TypeCF##Ref NSToCFCast(TypeNS* ns_val); \
+TypeNS* CFToNSCast(TypeCF##Ref cf_val); \
+TypeCF##Ref NSToCFCast(TypeNS* ns_val); \
} \
}
@@ -224,8 +223,8 @@
\
namespace base { \
namespace mac { \
-BASE_EXPORT NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val); \
-BASE_EXPORT CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val); \
+NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val); \
+CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val); \
} \
}
@@ -286,10 +285,10 @@
T CFCastStrict(const CFTypeRef& cf_val);
#define CF_CAST_DECL(TypeCF) \
-template<> BASE_EXPORT TypeCF##Ref \
+template<> TypeCF##Ref \
CFCast<TypeCF##Ref>(const CFTypeRef& cf_val);\
\
-template<> BASE_EXPORT TypeCF##Ref \
+template<> TypeCF##Ref \
CFCastStrict<TypeCF##Ref>(const CFTypeRef& cf_val);
CF_CAST_DECL(CFArray);
@@ -361,7 +360,7 @@
// Helper function for GetValueFromDictionary to create the error message
// that appears when a type mismatch is encountered.
-BASE_EXPORT std::string GetValueFromDictionaryErrorMessage(
+std::string GetValueFromDictionaryErrorMessage(
CFStringRef key, const std::string& expected_type, CFTypeRef value);
// Utility function to pull out a value from a dictionary, check its type, and
@@ -382,16 +381,16 @@
}
// Converts |path| to an autoreleased NSString. Returns nil if |path| is empty.
-BASE_EXPORT NSString* FilePathToNSString(const FilePath& path);
+NSString* FilePathToNSString(const FilePath& path);
// Converts |str| to a FilePath. Returns an empty path if |str| is nil.
-BASE_EXPORT FilePath NSStringToFilePath(NSString* str);
+FilePath NSStringToFilePath(NSString* str);
#if defined(__OBJC__)
// Converts |range| to an NSRange, returning the new range in |range_out|.
// Returns true if conversion was successful, false if the values of |range|
// could not be converted to NSUIntegers.
-BASE_EXPORT bool CFRangeToNSRange(CFRange range,
+bool CFRangeToNSRange(CFRange range,
NSRange* range_out) WARN_UNUSED_RESULT;
#endif // defined(__OBJC__)
@@ -403,9 +402,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_EXPORT extern std::ostream& operator<<(std::ostream& o,
+extern std::ostream& operator<<(std::ostream& o,
const CFErrorRef err);
-BASE_EXPORT extern std::ostream& operator<<(std::ostream& o,
+extern std::ostream& operator<<(std::ostream& o,
const CFStringRef str);
#endif // BASE_MAC_FOUNDATION_UTIL_H_
diff --git a/base/mac/foundation_util.mm b/base/mac/foundation_util.mm
index ae19544..a0c5cec 100644
--- a/base/mac/foundation_util.mm
+++ b/base/mac/foundation_util.mm
@@ -80,7 +80,7 @@
g_override_am_i_bundled_value = value;
}
-BASE_EXPORT void ClearAmIBundledCache() {
+void ClearAmIBundledCache() {
g_cached_am_i_bundled_called = false;
}
diff --git a/base/mac/mac_logging.h b/base/mac/mac_logging.h
index 8930e0f..148b383 100644
--- a/base/mac/mac_logging.h
+++ b/base/mac/mac_logging.h
@@ -5,7 +5,6 @@
#ifndef BASE_MAC_MAC_LOGGING_H_
#define BASE_MAC_MAC_LOGGING_H_
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "build_config.h"
@@ -30,9 +29,9 @@
namespace logging {
// Returns a UTF8 description from an OS X Status error.
-BASE_EXPORT std::string DescriptionFromOSStatus(OSStatus err);
+std::string DescriptionFromOSStatus(OSStatus err);
-class BASE_EXPORT OSStatusLogMessage : public logging::LogMessage {
+class OSStatusLogMessage : public logging::LogMessage {
public:
OSStatusLogMessage(const char* file_path,
int line,
diff --git a/base/mac/mac_util.h b/base/mac/mac_util.h
index 37e5b67..96dda1d 100644
--- a/base/mac/mac_util.h
+++ b/base/mac/mac_util.h
@@ -10,7 +10,6 @@
#import <CoreGraphics/CoreGraphics.h>
-#include "base/base_export.h"
namespace base {
@@ -33,21 +32,21 @@
// Returns an sRGB color space. The return value is a static value; do not
// release it!
-BASE_EXPORT CGColorSpaceRef GetSRGBColorSpace();
+CGColorSpaceRef GetSRGBColorSpace();
// Returns the generic RGB color space. The return value is a static value; do
// not release it!
-BASE_EXPORT CGColorSpaceRef GetGenericRGBColorSpace();
+CGColorSpaceRef GetGenericRGBColorSpace();
// Returns the color space being used by the main display. The return value
// is a static value; do not release it!
-BASE_EXPORT CGColorSpaceRef GetSystemColorSpace();
+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_EXPORT void RequestFullScreen(FullScreenMode mode);
+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(),
@@ -55,21 +54,21 @@
// state. For example, if there are no other outstanding
// |kFullScreenModeAutoHideAll| requests, this will reshow the menu bar. Must
// be called on main thread.
-BASE_EXPORT void ReleaseFullScreen(FullScreenMode mode);
+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_EXPORT void SwitchFullScreenModes(FullScreenMode from_mode,
+void SwitchFullScreenModes(FullScreenMode from_mode,
FullScreenMode to_mode);
// Excludes the file given by |file_path| from being backed up by Time Machine.
-BASE_EXPORT bool SetFileBackupExclusion(const FilePath& file_path);
+bool SetFileBackupExclusion(const FilePath& file_path);
// 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_EXPORT bool CheckLoginItemStatus(bool* is_hidden);
+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
@@ -77,34 +76,34 @@
// as "Options->Open on Login".
// Does nothing if the application is already set up as Login Item with
// specified hide flag.
-BASE_EXPORT void AddToLoginItems(bool hide_on_startup);
+void AddToLoginItems(bool hide_on_startup);
// Removes the current application from the list Of Login Items.
-BASE_EXPORT void RemoveFromLoginItems();
+void RemoveFromLoginItems();
// Returns true if the current process was automatically launched as a
// 'Login Item' or via Lion's Resume. Used to suppress opening windows.
-BASE_EXPORT bool WasLaunchedAsLoginOrResumeItem();
+bool WasLaunchedAsLoginOrResumeItem();
// Returns true if the current process was automatically launched as a
// 'Login Item' or via Resume, and the 'Reopen windows when logging back in'
// checkbox was selected by the user. This indicates that the previous
// session should be restored.
-BASE_EXPORT bool WasLaunchedAsLoginItemRestoreState();
+bool WasLaunchedAsLoginItemRestoreState();
// Returns true if the current process was automatically launched as a
// 'Login Item' with 'hide on startup' flag. Used to suppress opening windows.
-BASE_EXPORT bool WasLaunchedAsHiddenLoginItem();
+bool WasLaunchedAsHiddenLoginItem();
// Remove the quarantine xattr from the given file. Returns false if there was
// an error, or true otherwise.
-BASE_EXPORT bool RemoveQuarantineAttribute(const FilePath& file_path);
+bool RemoveQuarantineAttribute(const FilePath& file_path);
namespace internal {
// Returns the system's Mac OS X minor version. This is the |y| value
// in 10.y or 10.y.z.
-BASE_EXPORT int MacOSXMinorVersion();
+int MacOSXMinorVersion();
} // namespace internal
@@ -167,11 +166,11 @@
// Retrieve the system's model identifier string from the IOKit registry:
// for example, "MacPro4,1", "MacBookPro6,1". Returns empty string upon
// failure.
-BASE_EXPORT std::string GetModelIdentifier();
+std::string GetModelIdentifier();
// Parse a model identifier string; for example, into ("MacBookPro", 6, 1).
// If any error occurs, none of the input pointers are touched.
-BASE_EXPORT bool ParseModelIdentifier(const std::string& ident,
+bool ParseModelIdentifier(const std::string& ident,
std::string* type,
int32_t* major,
int32_t* minor);
diff --git a/base/mac/mach_logging.h b/base/mac/mach_logging.h
index 7aa5856..e32e1db 100644
--- a/base/mac/mach_logging.h
+++ b/base/mac/mach_logging.h
@@ -7,7 +7,6 @@
#include <mach/mach.h>
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "build_config.h"
@@ -33,7 +32,7 @@
namespace logging {
-class BASE_EXPORT MachLogMessage : public logging::LogMessage {
+class MachLogMessage : public logging::LogMessage {
public:
MachLogMessage(const char* file_path,
int line,
@@ -77,7 +76,7 @@
namespace logging {
-class BASE_EXPORT BootstrapLogMessage : public logging::LogMessage {
+class BootstrapLogMessage : public logging::LogMessage {
public:
BootstrapLogMessage(const char* file_path,
int line,
diff --git a/base/mac/scoped_mach_port.h b/base/mac/scoped_mach_port.h
index 67fed6b..9b4470d 100644
--- a/base/mac/scoped_mach_port.h
+++ b/base/mac/scoped_mach_port.h
@@ -7,7 +7,6 @@
#include <mach/mach.h>
-#include "base/base_export.h"
#include "base/scoped_generic.h"
namespace base {
@@ -15,20 +14,20 @@
namespace internal {
-struct BASE_EXPORT SendRightTraits {
+struct SendRightTraits {
static mach_port_t InvalidValue() {
return MACH_PORT_NULL;
}
- BASE_EXPORT static void Free(mach_port_t port);
+ static void Free(mach_port_t port);
};
-struct BASE_EXPORT ReceiveRightTraits {
+struct ReceiveRightTraits {
static mach_port_t InvalidValue() {
return MACH_PORT_NULL;
}
- BASE_EXPORT static void Free(mach_port_t port);
+ static void Free(mach_port_t port);
};
struct PortSetTraits {
@@ -36,7 +35,7 @@
return MACH_PORT_NULL;
}
- BASE_EXPORT static void Free(mach_port_t port);
+ static void Free(mach_port_t port);
};
} // namespace internal
diff --git a/base/mac/scoped_nsautorelease_pool.h b/base/mac/scoped_nsautorelease_pool.h
index 4d15e6d..017f1c0 100644
--- a/base/mac/scoped_nsautorelease_pool.h
+++ b/base/mac/scoped_nsautorelease_pool.h
@@ -5,7 +5,6 @@
#ifndef BASE_MAC_SCOPED_NSAUTORELEASE_POOL_H_
#define BASE_MAC_SCOPED_NSAUTORELEASE_POOL_H_
-#include "base/base_export.h"
#include "base/macros.h"
#if defined(__OBJC__)
@@ -22,7 +21,7 @@
// be maintained in ordinary C++ code without bringing in any direct Objective-C
// dependency.
-class BASE_EXPORT ScopedNSAutoreleasePool {
+class ScopedNSAutoreleasePool {
public:
ScopedNSAutoreleasePool();
~ScopedNSAutoreleasePool();
diff --git a/base/mac/scoped_nsobject.h b/base/mac/scoped_nsobject.h
index d970d03..45ab325 100644
--- a/base/mac/scoped_nsobject.h
+++ b/base/mac/scoped_nsobject.h
@@ -12,7 +12,6 @@
// singled out because it is most typically included from other header files.
#import <Foundation/NSObject.h>
-#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/mac/scoped_typeref.h"
@@ -51,11 +50,11 @@
namespace internal {
-BASE_EXPORT id ScopedNSProtocolTraitsRetain(__unsafe_unretained id obj)
+id ScopedNSProtocolTraitsRetain(__unsafe_unretained id obj)
__attribute((ns_returns_not_retained));
-BASE_EXPORT id ScopedNSProtocolTraitsAutoRelease(__unsafe_unretained id obj)
+id ScopedNSProtocolTraitsAutoRelease(__unsafe_unretained id obj)
__attribute((ns_returns_not_retained));
-BASE_EXPORT void ScopedNSProtocolTraitsRelease(__unsafe_unretained id obj);
+void ScopedNSProtocolTraitsRelease(__unsafe_unretained id obj);
// Traits for ScopedTypeRef<>. As this class may be compiled from file with
// Automatic Reference Counting enable or not all methods have annotation to
diff --git a/base/mac/sdk_forward_declarations.h b/base/mac/sdk_forward_declarations.h
index 7993870..c00e1f5 100644
--- a/base/mac/sdk_forward_declarations.h
+++ b/base/mac/sdk_forward_declarations.h
@@ -19,7 +19,6 @@
#import <QuartzCore/QuartzCore.h>
#include <stdint.h>
-#include "base/base_export.h"
#include "base/mac/availability.h"
// ----------------------------------------------------------------------------
@@ -77,10 +76,10 @@
extern "C" {
#if !defined(MAC_OS_X_VERSION_10_10) || \
MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_10
-BASE_EXPORT extern NSString* const CIDetectorTypeQRCode;
-BASE_EXPORT extern NSString* const NSUserActivityTypeBrowsingWeb;
-BASE_EXPORT extern NSString* const NSAppearanceNameVibrantDark;
-BASE_EXPORT extern NSString* const NSAppearanceNameVibrantLight;
+extern NSString* const CIDetectorTypeQRCode;
+extern NSString* const NSUserActivityTypeBrowsingWeb;
+extern NSString* const NSAppearanceNameVibrantDark;
+extern NSString* const NSAppearanceNameVibrantLight;
#endif // MAC_OS_X_VERSION_10_10
} // extern "C"
@@ -170,7 +169,7 @@
extern "C" {
#if !defined(MAC_OS_X_VERSION_10_11) || \
MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_11
-BASE_EXPORT extern NSString* const CIDetectorTypeText;
+extern NSString* const CIDetectorTypeText;
#endif // MAC_OS_X_VERSION_10_11
} // extern "C"
@@ -329,6 +328,6 @@
// declared in the OSX 10.9+ SDK, so when compiling against an OSX 10.9+ SDK,
// declare the symbol.
// ----------------------------------------------------------------------------
-BASE_EXPORT extern "C" NSString* const kCWSSIDDidChangeNotification;
+extern "C" NSString* const kCWSSIDDidChangeNotification;
#endif // BASE_MAC_SDK_FORWARD_DECLARATIONS_H_
diff --git a/base/md5.h b/base/md5.h
index ef64178..e6345b1 100644
--- a/base/md5.h
+++ b/base/md5.h
@@ -8,7 +8,6 @@
#include <stddef.h>
#include <stdint.h>
-#include "base/base_export.h"
#include "base/strings/string_piece.h"
namespace base {
@@ -47,31 +46,31 @@
// Initializes the given MD5 context structure for subsequent calls to
// MD5Update().
-BASE_EXPORT void MD5Init(MD5Context* context);
+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_EXPORT void MD5Update(MD5Context* context, const StringPiece& data);
+void MD5Update(MD5Context* context, const StringPiece& data);
// Finalizes the MD5 operation and fills the buffer with the digest.
-BASE_EXPORT void MD5Final(MD5Digest* digest, MD5Context* context);
+void MD5Final(MD5Digest* digest, MD5Context* context);
// MD5IntermediateFinal() generates a digest without finalizing the MD5
// operation. Can be used to generate digests for the input seen thus far,
// without affecting the digest generated for the entire input.
-BASE_EXPORT void MD5IntermediateFinal(MD5Digest* digest,
+void MD5IntermediateFinal(MD5Digest* digest,
const MD5Context* context);
// Converts a digest into human-readable hexadecimal.
-BASE_EXPORT std::string MD5DigestToBase16(const MD5Digest& digest);
+std::string MD5DigestToBase16(const MD5Digest& digest);
// 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_EXPORT void MD5Sum(const void* data, size_t length, MD5Digest* digest);
+void MD5Sum(const void* data, size_t length, MD5Digest* digest);
// Returns the MD5 (in hexadecimal) of a string.
-BASE_EXPORT std::string MD5String(const StringPiece& str);
+std::string MD5String(const StringPiece& str);
} // namespace base
diff --git a/base/memory/ref_counted.h b/base/memory/ref_counted.h
index 5cb731c..9447d51 100644
--- a/base/memory/ref_counted.h
+++ b/base/memory/ref_counted.h
@@ -10,7 +10,6 @@
#include <utility>
#include "base/atomic_ref_count.h"
-#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/macros.h"
@@ -20,7 +19,7 @@
namespace base {
namespace subtle {
-class BASE_EXPORT RefCountedBase {
+class RefCountedBase {
public:
bool HasOneRef() const { return ref_count_ == 1; }
@@ -85,7 +84,7 @@
DISALLOW_COPY_AND_ASSIGN(RefCountedBase);
};
-class BASE_EXPORT RefCountedThreadSafeBase {
+class RefCountedThreadSafeBase {
public:
bool HasOneRef() const;
@@ -145,7 +144,7 @@
// should properly std::move() the ref to avoid hitting this check).
// TODO(tzik): Cleanup existing use cases and remove
// ScopedAllowCrossThreadRefCountAccess.
-class BASE_EXPORT ScopedAllowCrossThreadRefCountAccess final {
+class ScopedAllowCrossThreadRefCountAccess final {
public:
ScopedAllowCrossThreadRefCountAccess() {}
~ScopedAllowCrossThreadRefCountAccess() {}
diff --git a/base/memory/weak_ptr.h b/base/memory/weak_ptr.h
index fcacec1..2a42692 100644
--- a/base/memory/weak_ptr.h
+++ b/base/memory/weak_ptr.h
@@ -73,7 +73,6 @@
#include <cstddef>
#include <type_traits>
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
@@ -87,11 +86,11 @@
// These classes are part of the WeakPtr implementation.
// DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
-class BASE_EXPORT WeakReference {
+class WeakReference {
public:
// Although Flag is bound to a specific SequencedTaskRunner, it may be
// deleted from another via base::WeakPtr::~WeakPtr().
- class BASE_EXPORT Flag : public RefCountedThreadSafe<Flag> {
+ class Flag : public RefCountedThreadSafe<Flag> {
public:
Flag();
@@ -121,7 +120,7 @@
scoped_refptr<const Flag> flag_;
};
-class BASE_EXPORT WeakReferenceOwner {
+class WeakReferenceOwner {
public:
WeakReferenceOwner();
~WeakReferenceOwner();
@@ -140,7 +139,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_EXPORT WeakPtrBase {
+class WeakPtrBase {
public:
WeakPtrBase();
~WeakPtrBase();
@@ -282,7 +281,7 @@
}
namespace internal {
-class BASE_EXPORT WeakPtrFactoryBase {
+class WeakPtrFactoryBase {
protected:
WeakPtrFactoryBase(uintptr_t ptr);
~WeakPtrFactoryBase();
diff --git a/base/posix/file_descriptor_shuffle.h b/base/posix/file_descriptor_shuffle.h
index 2afdc28..f2e8877 100644
--- a/base/posix/file_descriptor_shuffle.h
+++ b/base/posix/file_descriptor_shuffle.h
@@ -23,7 +23,6 @@
#include <vector>
-#include "base/base_export.h"
#include "base/compiler_specific.h"
namespace base {
@@ -47,7 +46,7 @@
// An implementation of the InjectionDelegate interface using the file
// descriptor table of the current process as the domain.
-class BASE_EXPORT FileDescriptorTableInjection : public InjectionDelegate {
+class FileDescriptorTableInjection : public InjectionDelegate {
bool Duplicate(int* result, int fd) override;
bool Move(int src, int dest) override;
void Close(int fd) override;
@@ -69,10 +68,10 @@
typedef std::vector<InjectionArc> InjectiveMultimap;
-BASE_EXPORT bool PerformInjectiveMultimap(const InjectiveMultimap& map,
+bool PerformInjectiveMultimap(const InjectiveMultimap& map,
InjectionDelegate* delegate);
-BASE_EXPORT bool PerformInjectiveMultimapDestructive(
+bool PerformInjectiveMultimapDestructive(
InjectiveMultimap* map,
InjectionDelegate* delegate);
diff --git a/base/posix/safe_strerror.h b/base/posix/safe_strerror.h
index 2945312..5a2f888 100644
--- a/base/posix/safe_strerror.h
+++ b/base/posix/safe_strerror.h
@@ -9,7 +9,6 @@
#include <string>
-#include "base/base_export.h"
namespace base {
@@ -29,7 +28,7 @@
// result is always null-terminated. The value of errno is never changed.
//
// Use this instead of strerror_r().
-BASE_EXPORT void safe_strerror_r(int err, char *buf, size_t len);
+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.
@@ -37,7 +36,7 @@
// 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_EXPORT std::string safe_strerror(int err);
+std::string safe_strerror(int err);
} // namespace base
diff --git a/base/process/kill.h b/base/process/kill.h
index 384087c..4bed1e5 100644
--- a/base/process/kill.h
+++ b/base/process/kill.h
@@ -61,14 +61,14 @@
// 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_EXPORT bool KillProcesses(const FilePath::StringType& executable_name,
+bool KillProcesses(const FilePath::StringType& executable_name,
int exit_code,
const ProcessFilter* filter);
#if defined(OS_POSIX)
// Attempts to kill the process group identified by |process_group_id|. Returns
// true on success.
-BASE_EXPORT bool KillProcessGroup(ProcessHandle process_group_id);
+bool KillProcessGroup(ProcessHandle process_group_id);
#endif // defined(OS_POSIX)
// Get the termination status of the process by interpreting the
@@ -78,7 +78,7 @@
// 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_EXPORT TerminationStatus GetTerminationStatus(ProcessHandle handle,
+TerminationStatus GetTerminationStatus(ProcessHandle handle,
int* exit_code);
#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
@@ -97,13 +97,13 @@
// GetTerminationStatus as the child will be reaped when WaitForExitCode
// returns, and this information will be lost.
//
-BASE_EXPORT TerminationStatus GetKnownDeadTerminationStatus(
+TerminationStatus GetKnownDeadTerminationStatus(
ProcessHandle handle, int* exit_code);
#if defined(OS_LINUX)
// Spawns a thread to wait asynchronously for the child |process| to exit
// and then reaps it.
-BASE_EXPORT void EnsureProcessGetsReaped(Process process);
+void EnsureProcessGetsReaped(Process process);
#endif // defined(OS_LINUX)
#endif // defined(OS_POSIX) && !defined(OS_FUCHSIA)
@@ -114,7 +114,7 @@
// 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_EXPORT bool WaitForProcessesToExit(
+bool WaitForProcessesToExit(
const FilePath::StringType& executable_name,
base::TimeDelta wait,
const ProcessFilter* filter);
@@ -125,7 +125,7 @@
// 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_EXPORT bool CleanupProcesses(const FilePath::StringType& executable_name,
+bool CleanupProcesses(const FilePath::StringType& executable_name,
base::TimeDelta wait,
int exit_code,
const ProcessFilter* filter);
diff --git a/base/process/memory.h b/base/process/memory.h
index 5ed3acc..49dad5d 100644
--- a/base/process/memory.h
+++ b/base/process/memory.h
@@ -7,7 +7,6 @@
#include <stddef.h>
-#include "base/base_export.h"
#include "base/process/process_handle.h"
#include "build_config.h"
@@ -23,17 +22,17 @@
// Enables 'terminate on heap corruption' flag. Helps protect against heap
// overflow. Has no effect if the OS doesn't provide the necessary facility.
-BASE_EXPORT void EnableTerminationOnHeapCorruption();
+void EnableTerminationOnHeapCorruption();
// Turns on process termination if memory runs out.
-BASE_EXPORT void EnableTerminationOnOutOfMemory();
+void EnableTerminationOnOutOfMemory();
// Terminates process. Should be called only for out of memory errors.
// Crash reporting classifies such crashes as OOM.
-BASE_EXPORT void TerminateBecauseOutOfMemory(size_t size);
+void TerminateBecauseOutOfMemory(size_t size);
#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX)
-BASE_EXPORT extern size_t g_oom_size;
+extern size_t g_oom_size;
// The maximum allowed value for the OOM score.
const int kMaxOomScore = 1000;
@@ -45,7 +44,7 @@
// of [0, 1000], then we revert to using the older oom_adj, and
// translate the given value into [0, 15]. Some aliasing of values
// may occur in that case, of course.
-BASE_EXPORT bool AdjustOOMScore(ProcessId process, int score);
+bool AdjustOOMScore(ProcessId process, int score);
#endif
#if defined(OS_WIN)
@@ -72,9 +71,9 @@
// specifically ASan and other sanitizers.
// Return value tells whether the allocation succeeded. If it fails |result| is
// set to NULL, otherwise it holds the memory address.
-BASE_EXPORT WARN_UNUSED_RESULT bool UncheckedMalloc(size_t size,
+WARN_UNUSED_RESULT bool UncheckedMalloc(size_t size,
void** result);
-BASE_EXPORT WARN_UNUSED_RESULT bool UncheckedCalloc(size_t num_items,
+WARN_UNUSED_RESULT bool UncheckedCalloc(size_t num_items,
size_t size,
void** result);
diff --git a/base/process/process.h b/base/process/process.h
index dbfc701..bef0aef 100644
--- a/base/process/process.h
+++ b/base/process/process.h
@@ -5,7 +5,6 @@
#ifndef BASE_PROCESS_PROCESS_H_
#define BASE_PROCESS_PROCESS_H_
-#include "base/base_export.h"
#include "base/macros.h"
#include "base/process/process_handle.h"
#include "base/time/time.h"
@@ -30,7 +29,7 @@
// POSIX: The underlying ProcessHandle is not guaranteed to remain valid after
// the process dies, and it may be reused by the system, which means that it may
// end up pointing to the wrong process.
-class BASE_EXPORT Process {
+class Process {
public:
// On Windows, this takes ownership of |handle|. On POSIX, this does not take
// ownership of |handle|.
diff --git a/base/process/process_handle.h b/base/process/process_handle.h
index 8079e56..f241391 100644
--- a/base/process/process_handle.h
+++ b/base/process/process_handle.h
@@ -8,7 +8,6 @@
#include <stdint.h>
#include <sys/types.h>
-#include "base/base_export.h"
#include "base/files/file_path.h"
#include "build_config.h"
@@ -47,13 +46,13 @@
// Returns the id of the current process.
// Note that on some platforms, this is not guaranteed to be unique across
// processes (use GetUniqueIdForProcess if uniqueness is required).
-BASE_EXPORT ProcessId GetCurrentProcId();
+ProcessId GetCurrentProcId();
// Returns a unique ID for the current process. The ID will be unique across all
// currently running processes within the chrome session, but IDs of terminated
// processes may be reused. This returns an opaque value that is different from
// a process's PID.
-BASE_EXPORT uint32_t GetUniqueIdForProcess();
+uint32_t GetUniqueIdForProcess();
#if defined(OS_LINUX)
// When a process is started in a different PID namespace from the browser
@@ -62,12 +61,12 @@
// WARNING: To avoid inconsistent results from GetUniqueIdForProcess, this
// should only be called very early after process startup - ideally as soon
// after process creation as possible.
-BASE_EXPORT void InitUniqueIdForProcessInPidNamespace(
+void InitUniqueIdForProcessInPidNamespace(
ProcessId pid_outside_of_namespace);
#endif
// Returns the ProcessHandle of the current process.
-BASE_EXPORT ProcessHandle GetCurrentProcessHandle();
+ProcessHandle GetCurrentProcessHandle();
// Returns the process ID for the specified process. This is functionally the
// same as Windows' GetProcessId(), but works on versions of Windows before Win
@@ -75,18 +74,18 @@
// DEPRECATED. New code should be using Process::Pid() instead.
// Note that on some platforms, this is not guaranteed to be unique across
// processes.
-BASE_EXPORT ProcessId GetProcId(ProcessHandle process);
+ProcessId GetProcId(ProcessHandle process);
#if !defined(OS_FUCHSIA)
// Returns the ID for the parent of the given process. Not available on Fuchsia.
// Returning a negative value indicates an error, such as if the |process| does
// not exist. Returns 0 when |process| has no parent process.
-BASE_EXPORT ProcessId GetParentProcessId(ProcessHandle process);
+ProcessId GetParentProcessId(ProcessHandle process);
#endif // !defined(OS_FUCHSIA)
#if defined(OS_POSIX)
// Returns the path to the executable of the given process.
-BASE_EXPORT FilePath GetProcessExecutablePath(ProcessHandle process);
+FilePath GetProcessExecutablePath(ProcessHandle process);
#endif
} // namespace base
diff --git a/base/process/process_info.h b/base/process/process_info.h
index 8d5aa07..291ad9d 100644
--- a/base/process/process_info.h
+++ b/base/process/process_info.h
@@ -5,7 +5,6 @@
#ifndef BASE_PROCESS_PROCESS_INFO_H_
#define BASE_PROCESS_PROCESS_INFO_H_
-#include "base/base_export.h"
#include "build_config.h"
namespace base {
@@ -13,7 +12,7 @@
class Time;
// Vends information about the current process.
-class BASE_EXPORT CurrentProcessInfo {
+class CurrentProcessInfo {
public:
// Returns the time at which the process was launched. May be empty if an
// error occurred retrieving the information.
@@ -30,10 +29,10 @@
// Returns the integrity level of the process. Returns INTEGRITY_UNKNOWN in the
// case of an underlying system failure.
-BASE_EXPORT IntegrityLevel GetCurrentProcessIntegrityLevel();
+IntegrityLevel GetCurrentProcessIntegrityLevel();
// Determines whether the current process is elevated.
-BASE_EXPORT bool IsCurrentProcessElevated();
+bool IsCurrentProcessElevated();
#endif // defined(OS_WIN)
diff --git a/base/process/process_iterator.h b/base/process/process_iterator.h
index e563567..532104a 100644
--- a/base/process/process_iterator.h
+++ b/base/process/process_iterator.h
@@ -13,7 +13,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/process/process.h"
@@ -37,7 +36,7 @@
const wchar_t* exe_file() const { return szExeFile; }
};
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-struct BASE_EXPORT ProcessEntry {
+struct ProcessEntry {
ProcessEntry();
ProcessEntry(const ProcessEntry& other);
~ProcessEntry();
@@ -73,7 +72,7 @@
// current machine with a specified filter.
// To use, create an instance and then call NextProcessEntry() until it returns
// false.
-class BASE_EXPORT ProcessIterator {
+class ProcessIterator {
public:
typedef std::list<ProcessEntry> ProcessEntries;
@@ -123,7 +122,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_EXPORT NamedProcessIterator : public ProcessIterator {
+class NamedProcessIterator : public ProcessIterator {
public:
NamedProcessIterator(const FilePath::StringType& executable_name,
const ProcessFilter* filter);
@@ -141,7 +140,7 @@
// 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_EXPORT int GetProcessCount(const FilePath::StringType& executable_name,
+int GetProcessCount(const FilePath::StringType& executable_name,
const ProcessFilter* filter);
} // namespace base
diff --git a/base/sha1.h b/base/sha1.h
index 902e301..5394606 100644
--- a/base/sha1.h
+++ b/base/sha1.h
@@ -9,7 +9,6 @@
#include <string>
-#include "base/base_export.h"
namespace base {
@@ -19,11 +18,11 @@
// Computes the SHA-1 hash of the input string |str| and returns the full
// hash.
-BASE_EXPORT std::string SHA1HashString(const std::string& str);
+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 kSHA1Length bytes long.
-BASE_EXPORT void SHA1HashBytes(const unsigned char* data, size_t len,
+void SHA1HashBytes(const unsigned char* data, size_t len,
unsigned char* hash);
} // namespace base
diff --git a/base/strings/string16.h b/base/strings/string16.h
index 570a6d5..b143375 100644
--- a/base/strings/string16.h
+++ b/base/strings/string16.h
@@ -33,7 +33,6 @@
#include <functional>
#include <string>
-#include "base/base_export.h"
#include "build_config.h"
#if defined(WCHAR_T_IS_UTF16)
@@ -56,12 +55,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_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);
+int c16memcmp(const char16* s1, const char16* s2, size_t n);
+size_t c16len(const char16* s);
+const char16* c16memchr(const char16* s, char16 c, size_t n);
+char16* c16memmove(char16* s1, const char16* s2, size_t n);
+char16* c16memcpy(char16* s1, const char16* s2, size_t n);
+char16* c16memset(char16* s, char16 c, size_t n);
// This namespace contains the implementation of base::string16 along with
// things that need to be found via argument-dependent lookup from a
@@ -146,11 +145,11 @@
namespace string16_internals {
-BASE_EXPORT extern std::ostream& operator<<(std::ostream& out,
+extern std::ostream& operator<<(std::ostream& out,
const string16& str);
// This is required by googletest to print a readable output on test failures.
-BASE_EXPORT extern void PrintTo(const string16& str, std::ostream* out);
+extern void PrintTo(const string16& str, std::ostream* out);
} // namespace string16_internals
@@ -195,7 +194,7 @@
//
// TODO(mark): File this bug with Apple and update this note with a bug number.
-extern template class BASE_EXPORT
+extern template class
std::basic_string<base::char16,
base::string16_internals::string16_char_traits>;
diff --git a/base/strings/string_number_conversions.h b/base/strings/string_number_conversions.h
index 4eb870e..d31f09b 100644
--- a/base/strings/string_number_conversions.h
+++ b/base/strings/string_number_conversions.h
@@ -11,7 +11,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
#include "build_config.h"
@@ -41,18 +40,18 @@
// Number -> string conversions ------------------------------------------------
// Ignores locale! see warning above.
-BASE_EXPORT std::string NumberToString(int value);
-BASE_EXPORT string16 NumberToString16(int value);
-BASE_EXPORT std::string NumberToString(unsigned int value);
-BASE_EXPORT string16 NumberToString16(unsigned int value);
-BASE_EXPORT std::string NumberToString(long value);
-BASE_EXPORT string16 NumberToString16(long value);
-BASE_EXPORT std::string NumberToString(unsigned long value);
-BASE_EXPORT string16 NumberToString16(unsigned long value);
-BASE_EXPORT std::string NumberToString(long long value);
-BASE_EXPORT string16 NumberToString16(long long value);
-BASE_EXPORT std::string NumberToString(unsigned long long value);
-BASE_EXPORT string16 NumberToString16(unsigned long long value);
+std::string NumberToString(int value);
+string16 NumberToString16(int value);
+std::string NumberToString(unsigned int value);
+string16 NumberToString16(unsigned int value);
+std::string NumberToString(long value);
+string16 NumberToString16(long value);
+std::string NumberToString(unsigned long value);
+string16 NumberToString16(unsigned long value);
+std::string NumberToString(long long value);
+string16 NumberToString16(long long value);
+std::string NumberToString(unsigned long long value);
+string16 NumberToString16(unsigned long long value);
// Type-specific naming for backwards compatibility.
//
@@ -95,20 +94,20 @@
// - Empty string. |*output| will be set to 0.
// WARNING: Will write to |output| even when returning false.
// Read the comments above carefully.
-BASE_EXPORT bool StringToInt(StringPiece input, int* output);
-BASE_EXPORT bool StringToInt(StringPiece16 input, int* output);
+bool StringToInt(StringPiece input, int* output);
+bool StringToInt(StringPiece16 input, int* output);
-BASE_EXPORT bool StringToUint(StringPiece input, unsigned* output);
-BASE_EXPORT bool StringToUint(StringPiece16 input, unsigned* output);
+bool StringToUint(StringPiece input, unsigned* output);
+bool StringToUint(StringPiece16 input, unsigned* output);
-BASE_EXPORT bool StringToInt64(StringPiece input, int64_t* output);
-BASE_EXPORT bool StringToInt64(StringPiece16 input, int64_t* output);
+bool StringToInt64(StringPiece input, int64_t* output);
+bool StringToInt64(StringPiece16 input, int64_t* output);
-BASE_EXPORT bool StringToUint64(StringPiece input, uint64_t* output);
-BASE_EXPORT bool StringToUint64(StringPiece16 input, uint64_t* output);
+bool StringToUint64(StringPiece input, uint64_t* output);
+bool StringToUint64(StringPiece16 input, uint64_t* output);
-BASE_EXPORT bool StringToSizeT(StringPiece input, size_t* output);
-BASE_EXPORT bool StringToSizeT(StringPiece16 input, size_t* output);
+bool StringToSizeT(StringPiece input, size_t* output);
+bool StringToSizeT(StringPiece16 input, size_t* output);
// Hex encoding ----------------------------------------------------------------
@@ -118,35 +117,35 @@
// 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_EXPORT std::string HexEncode(const void* bytes, size_t size);
+std::string HexEncode(const void* bytes, size_t size);
// Best effort conversion, see StringToInt above for restrictions.
// Will only successful parse hex values that will fit into |output|, i.e.
// -0x80000000 < |input| < 0x7FFFFFFF.
-BASE_EXPORT bool HexStringToInt(StringPiece input, int* output);
+bool HexStringToInt(StringPiece input, int* output);
// Best effort conversion, see StringToInt above for restrictions.
// Will only successful parse hex values that will fit into |output|, i.e.
// 0x00000000 < |input| < 0xFFFFFFFF.
// The string is not required to start with 0x.
-BASE_EXPORT bool HexStringToUInt(StringPiece input, uint32_t* output);
+bool HexStringToUInt(StringPiece input, uint32_t* output);
// Best effort conversion, see StringToInt above for restrictions.
// Will only successful parse hex values that will fit into |output|, i.e.
// -0x8000000000000000 < |input| < 0x7FFFFFFFFFFFFFFF.
-BASE_EXPORT bool HexStringToInt64(StringPiece input, int64_t* output);
+bool HexStringToInt64(StringPiece input, int64_t* output);
// Best effort conversion, see StringToInt above for restrictions.
// Will only successful parse hex values that will fit into |output|, i.e.
// 0x0000000000000000 < |input| < 0xFFFFFFFFFFFFFFFF.
// The string is not required to start with 0x.
-BASE_EXPORT bool HexStringToUInt64(StringPiece input, uint64_t* output);
+bool HexStringToUInt64(StringPiece input, uint64_t* 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_EXPORT bool HexStringToBytes(StringPiece input,
+bool HexStringToBytes(StringPiece input,
std::vector<uint8_t>* output);
} // namespace base
diff --git a/base/strings/string_piece.cc b/base/strings/string_piece.cc
index c82a223..be22261 100644
--- a/base/strings/string_piece.cc
+++ b/base/strings/string_piece.cc
@@ -254,7 +254,7 @@
}
// 16-bit brute-force version.
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
+size_t find_first_not_of(const StringPiece16& self,
const StringPiece16& s,
size_t pos) {
if (self.size() == 0)
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index 775ea7c..6b19b80 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -27,7 +27,6 @@
#include <iosfwd>
#include <string>
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/strings/char_traits.h"
#include "base/strings/string16.h"
@@ -46,105 +45,105 @@
// template internal to the .cc file.
namespace internal {
-BASE_EXPORT void CopyToString(const StringPiece& self, std::string* target);
-BASE_EXPORT void CopyToString(const StringPiece16& self, string16* target);
+void CopyToString(const StringPiece& self, std::string* target);
+void CopyToString(const StringPiece16& self, string16* target);
-BASE_EXPORT void AppendToString(const StringPiece& self, std::string* target);
-BASE_EXPORT void AppendToString(const StringPiece16& self, string16* target);
+void AppendToString(const StringPiece& self, std::string* target);
+void AppendToString(const StringPiece16& self, string16* target);
-BASE_EXPORT size_t copy(const StringPiece& self,
+size_t copy(const StringPiece& self,
char* buf,
size_t n,
size_t pos);
-BASE_EXPORT size_t copy(const StringPiece16& self,
+size_t copy(const StringPiece16& self,
char16* buf,
size_t n,
size_t pos);
-BASE_EXPORT size_t find(const StringPiece& self,
+size_t find(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find(const StringPiece16& self,
+size_t find(const StringPiece16& self,
const StringPiece16& s,
size_t pos);
-BASE_EXPORT size_t find(const StringPiece& self,
+size_t find(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT size_t find(const StringPiece16& self,
+size_t find(const StringPiece16& self,
char16 c,
size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece& self,
+size_t rfind(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece16& self,
+size_t rfind(const StringPiece16& self,
const StringPiece16& s,
size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece& self,
+size_t rfind(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece16& self,
+size_t rfind(const StringPiece16& self,
char16 c,
size_t pos);
-BASE_EXPORT size_t find_first_of(const StringPiece& self,
+size_t find_first_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find_first_of(const StringPiece16& self,
+size_t find_first_of(const StringPiece16& self,
const StringPiece16& s,
size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
+size_t find_first_not_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
+size_t find_first_not_of(const StringPiece16& self,
const StringPiece16& s,
size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
+size_t find_first_not_of(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
+size_t find_first_not_of(const StringPiece16& self,
char16 c,
size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece& self,
+size_t find_last_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece16& self,
+size_t find_last_of(const StringPiece16& self,
const StringPiece16& s,
size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece& self,
+size_t find_last_of(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece16& self,
+size_t find_last_of(const StringPiece16& self,
char16 c,
size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
+size_t find_last_not_of(const StringPiece& self,
const StringPiece& s,
size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
+size_t find_last_not_of(const StringPiece16& self,
const StringPiece16& s,
size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
+size_t find_last_not_of(const StringPiece16& self,
char16 c,
size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
+size_t find_last_not_of(const StringPiece& self,
char c,
size_t pos);
-BASE_EXPORT StringPiece substr(const StringPiece& self,
+StringPiece substr(const StringPiece& self,
size_t pos,
size_t n);
-BASE_EXPORT StringPiece16 substr(const StringPiece16& self,
+StringPiece16 substr(const StringPiece16& self,
size_t pos,
size_t n);
#if DCHECK_IS_ON()
// Asserts that begin <= end to catch some errors with iterator usage.
-BASE_EXPORT void AssertIteratorsInOrder(std::string::const_iterator begin,
+void AssertIteratorsInOrder(std::string::const_iterator begin,
std::string::const_iterator end);
-BASE_EXPORT void AssertIteratorsInOrder(string16::const_iterator begin,
+void AssertIteratorsInOrder(string16::const_iterator begin,
string16::const_iterator end);
#endif
@@ -382,13 +381,13 @@
// MSVC doesn't like complex extern templates and DLLs.
#if !defined(COMPILER_MSVC)
-extern template class BASE_EXPORT BasicStringPiece<std::string>;
-extern template class BASE_EXPORT BasicStringPiece<string16>;
+extern template class BasicStringPiece<std::string>;
+extern template class BasicStringPiece<string16>;
#endif
// StingPiece operators --------------------------------------------------------
-BASE_EXPORT bool operator==(const StringPiece& x, const StringPiece& y);
+bool operator==(const StringPiece& x, const StringPiece& y);
inline bool operator!=(const StringPiece& x, const StringPiece& y) {
return !(x == y);
@@ -444,7 +443,7 @@
return !(x < y);
}
-BASE_EXPORT std::ostream& operator<<(std::ostream& o,
+std::ostream& operator<<(std::ostream& o,
const StringPiece& piece);
// Hashing ---------------------------------------------------------------------
diff --git a/base/strings/string_split.h b/base/strings/string_split.h
index 24b9dfa..1a41d2e 100644
--- a/base/strings/string_split.h
+++ b/base/strings/string_split.h
@@ -9,7 +9,6 @@
#include <utility>
#include <vector>
-#include "base/base_export.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
@@ -43,12 +42,12 @@
//
// std::vector<std::string> tokens = base::SplitString(
// input, ",;", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
-BASE_EXPORT std::vector<std::string> SplitString(
+std::vector<std::string> SplitString(
StringPiece input,
StringPiece separators,
WhitespaceHandling whitespace,
SplitResult result_type);
-BASE_EXPORT std::vector<string16> SplitString(
+std::vector<string16> SplitString(
StringPiece16 input,
StringPiece16 separators,
WhitespaceHandling whitespace,
@@ -66,12 +65,12 @@
// base::KEEP_WHITESPACE,
// base::SPLIT_WANT_NONEMPTY)) {
// ...
-BASE_EXPORT std::vector<StringPiece> SplitStringPiece(
+std::vector<StringPiece> SplitStringPiece(
StringPiece input,
StringPiece separators,
WhitespaceHandling whitespace,
SplitResult result_type);
-BASE_EXPORT std::vector<StringPiece16> SplitStringPiece(
+std::vector<StringPiece16> SplitStringPiece(
StringPiece16 input,
StringPiece16 separators,
WhitespaceHandling whitespace,
@@ -83,19 +82,19 @@
// removes whitespace leading each key and trailing each value. Returns true
// only if each pair has a non-empty key and value. |key_value_pairs| will
// include ("","") pairs for entries without |key_value_delimiter|.
-BASE_EXPORT bool SplitStringIntoKeyValuePairs(StringPiece input,
+bool SplitStringIntoKeyValuePairs(StringPiece input,
char key_value_delimiter,
char key_value_pair_delimiter,
StringPairs* key_value_pairs);
// Similar to SplitString, but use a substring delimiter instead of a list of
// characters that are all possible delimiters.
-BASE_EXPORT std::vector<string16> SplitStringUsingSubstr(
+std::vector<string16> SplitStringUsingSubstr(
StringPiece16 input,
StringPiece16 delimiter,
WhitespaceHandling whitespace,
SplitResult result_type);
-BASE_EXPORT std::vector<std::string> SplitStringUsingSubstr(
+std::vector<std::string> SplitStringUsingSubstr(
StringPiece input,
StringPiece delimiter,
WhitespaceHandling whitespace,
@@ -113,12 +112,12 @@
// base::KEEP_WHITESPACE,
// base::SPLIT_WANT_NONEMPTY)) {
// ...
-BASE_EXPORT std::vector<StringPiece16> SplitStringPieceUsingSubstr(
+std::vector<StringPiece16> SplitStringPieceUsingSubstr(
StringPiece16 input,
StringPiece16 delimiter,
WhitespaceHandling whitespace,
SplitResult result_type);
-BASE_EXPORT std::vector<StringPiece> SplitStringPieceUsingSubstr(
+std::vector<StringPiece> SplitStringPieceUsingSubstr(
StringPiece input,
StringPiece delimiter,
WhitespaceHandling whitespace,
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index eaef690..98197d6 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -16,7 +16,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h" // For implicit conversions.
@@ -60,8 +59,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_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);
+size_t strlcpy(char* dst, const char* src, size_t dst_size);
+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
@@ -84,7 +83,7 @@
// working with wprintf.
//
// This function is intended to be called from base::vswprintf.
-BASE_EXPORT bool IsWprintfFormatPortable(const wchar_t* format);
+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.
@@ -105,12 +104,12 @@
}
// Converts the given string to it's ASCII-lowercase equivalent.
-BASE_EXPORT std::string ToLowerASCII(StringPiece str);
-BASE_EXPORT string16 ToLowerASCII(StringPiece16 str);
+std::string ToLowerASCII(StringPiece str);
+string16 ToLowerASCII(StringPiece16 str);
// Converts the given string to it's ASCII-uppercase equivalent.
-BASE_EXPORT std::string ToUpperASCII(StringPiece str);
-BASE_EXPORT string16 ToUpperASCII(StringPiece16 str);
+std::string ToUpperASCII(StringPiece str);
+string16 ToUpperASCII(StringPiece16 str);
// Functor for case-insensitive ASCII comparisons for STL algorithms like
// std::search.
@@ -134,33 +133,33 @@
// (unlike strcasecmp which can return values greater or less than 1/-1). For
// full Unicode support, use base::i18n::ToLower or base::i18h::FoldCase
// and then just call the normal string operators on the result.
-BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b);
-BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
+int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b);
+int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
// Equality for ASCII case-insensitive comparisons. For full Unicode support,
// use base::i18n::ToLower or base::i18h::FoldCase and then compare with either
// == or !=.
-BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b);
-BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
+bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b);
+bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
// Contains the set of characters representing whitespace in the corresponding
// encoding. Null-terminated. The ASCII versions are the whitespaces as defined
// by HTML5, and don't include control characters.
-BASE_EXPORT extern const wchar_t kWhitespaceWide[]; // Includes Unicode.
-BASE_EXPORT extern const char16 kWhitespaceUTF16[]; // Includes Unicode.
-BASE_EXPORT extern const char kWhitespaceASCII[];
-BASE_EXPORT extern const char16 kWhitespaceASCIIAs16[]; // No unicode.
+extern const wchar_t kWhitespaceWide[]; // Includes Unicode.
+extern const char16 kWhitespaceUTF16[]; // Includes Unicode.
+extern const char kWhitespaceASCII[];
+extern const char16 kWhitespaceASCIIAs16[]; // No unicode.
// Null-terminated string representing the UTF-8 byte order mark.
-BASE_EXPORT extern const char kUtf8ByteOrderMark[];
+extern const char kUtf8ByteOrderMark[];
// Removes characters in |remove_chars| from anywhere in |input|. Returns true
// if any characters were removed. |remove_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool RemoveChars(const string16& input,
+bool RemoveChars(const string16& input,
StringPiece16 remove_chars,
string16* output);
-BASE_EXPORT bool RemoveChars(const std::string& input,
+bool RemoveChars(const std::string& input,
StringPiece remove_chars,
std::string* output);
@@ -169,11 +168,11 @@
// the |replace_with| string. Returns true if any characters were replaced.
// |replace_chars| must be null-terminated.
// NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool ReplaceChars(const string16& input,
+bool ReplaceChars(const string16& input,
StringPiece16 replace_chars,
const string16& replace_with,
string16* output);
-BASE_EXPORT bool ReplaceChars(const std::string& input,
+bool ReplaceChars(const std::string& input,
StringPiece replace_chars,
const std::string& replace_with,
std::string* output);
@@ -191,25 +190,25 @@
//
// It is safe to use the same variable for both |input| and |output| (this is
// the normal usage to trim in-place).
-BASE_EXPORT bool TrimString(const string16& input,
+bool TrimString(const string16& input,
StringPiece16 trim_chars,
string16* output);
-BASE_EXPORT bool TrimString(const std::string& input,
+bool TrimString(const std::string& input,
StringPiece trim_chars,
std::string* output);
// StringPiece versions of the above. The returned pieces refer to the original
// buffer.
-BASE_EXPORT StringPiece16 TrimString(StringPiece16 input,
+StringPiece16 TrimString(StringPiece16 input,
StringPiece16 trim_chars,
TrimPositions positions);
-BASE_EXPORT StringPiece TrimString(StringPiece input,
+StringPiece TrimString(StringPiece input,
StringPiece trim_chars,
TrimPositions positions);
// Truncates a string to the nearest UTF-8 character that will leave
// the string less than or equal to the specified byte size.
-BASE_EXPORT void TruncateUTF8ToByteSize(const std::string& input,
+void TruncateUTF8ToByteSize(const std::string& input,
const size_t byte_size,
std::string* output);
@@ -220,15 +219,15 @@
//
// The std::string versions return where whitespace was found.
// NOTE: Safe to use the same variable for both input and output.
-BASE_EXPORT TrimPositions TrimWhitespace(const string16& input,
+TrimPositions TrimWhitespace(const string16& input,
TrimPositions positions,
string16* output);
-BASE_EXPORT StringPiece16 TrimWhitespace(StringPiece16 input,
+StringPiece16 TrimWhitespace(StringPiece16 input,
TrimPositions positions);
-BASE_EXPORT TrimPositions TrimWhitespaceASCII(const std::string& input,
+TrimPositions TrimWhitespaceASCII(const std::string& input,
TrimPositions positions,
std::string* output);
-BASE_EXPORT StringPiece TrimWhitespaceASCII(StringPiece input,
+StringPiece TrimWhitespaceASCII(StringPiece input,
TrimPositions positions);
// Searches for CR or LF characters. Removes all contiguous whitespace
@@ -239,17 +238,17 @@
// (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_EXPORT string16 CollapseWhitespace(
+string16 CollapseWhitespace(
const string16& text,
bool trim_sequences_with_line_breaks);
-BASE_EXPORT std::string CollapseWhitespaceASCII(
+std::string CollapseWhitespaceASCII(
const std::string& text,
bool trim_sequences_with_line_breaks);
// Returns true if |input| is empty or contains only characters found in
// |characters|.
-BASE_EXPORT bool ContainsOnlyChars(StringPiece input, StringPiece characters);
-BASE_EXPORT bool ContainsOnlyChars(StringPiece16 input,
+bool ContainsOnlyChars(StringPiece input, StringPiece characters);
+bool ContainsOnlyChars(StringPiece16 input,
StringPiece16 characters);
// Returns true if the specified string matches the criteria. How can a wide
@@ -266,24 +265,24 @@
//
// IsStringASCII assumes the input is likely all ASCII, and does not leave early
// if it is not the case.
-BASE_EXPORT bool IsStringUTF8(StringPiece str);
-BASE_EXPORT bool IsStringASCII(StringPiece str);
-BASE_EXPORT bool IsStringASCII(StringPiece16 str);
+bool IsStringUTF8(StringPiece str);
+bool IsStringASCII(StringPiece str);
+bool IsStringASCII(StringPiece16 str);
#if defined(WCHAR_T_IS_UTF32)
-BASE_EXPORT bool IsStringASCII(WStringPiece str);
+bool IsStringASCII(WStringPiece str);
#endif
// Compare the lower-case form of the given string against the given
// previously-lower-cased ASCII string (typically a constant).
-BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece str,
+bool LowerCaseEqualsASCII(StringPiece str,
StringPiece lowecase_ascii);
-BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece16 str,
+bool LowerCaseEqualsASCII(StringPiece16 str,
StringPiece lowecase_ascii);
// Performs a case-sensitive string compare of the given 16-bit string against
// the given 8-bit ASCII string (typically a constant). The behavior is
// undefined if the |ascii| string is not ASCII.
-BASE_EXPORT bool EqualsASCII(StringPiece16 str, StringPiece ascii);
+bool EqualsASCII(StringPiece16 str, StringPiece ascii);
// Indicates case sensitivity of comparisons. Only ASCII case insensitivity
// is supported. Full Unicode case-insensitive conversions would need to go in
@@ -298,16 +297,16 @@
INSENSITIVE_ASCII,
};
-BASE_EXPORT bool StartsWith(StringPiece str,
+bool StartsWith(StringPiece str,
StringPiece search_for,
CompareCase case_sensitivity);
-BASE_EXPORT bool StartsWith(StringPiece16 str,
+bool StartsWith(StringPiece16 str,
StringPiece16 search_for,
CompareCase case_sensitivity);
-BASE_EXPORT bool EndsWith(StringPiece str,
+bool EndsWith(StringPiece str,
StringPiece search_for,
CompareCase case_sensitivity);
-BASE_EXPORT bool EndsWith(StringPiece16 str,
+bool EndsWith(StringPiece16 str,
StringPiece16 search_for,
CompareCase case_sensitivity);
@@ -346,25 +345,25 @@
// 'a' -> 10
// 'B' -> 11
// Assumes the input is a valid hex character. DCHECKs in debug builds if not.
-BASE_EXPORT char HexDigitToInt(wchar_t c);
+char HexDigitToInt(wchar_t c);
// Returns true if it's a Unicode whitespace character.
-BASE_EXPORT bool IsUnicodeWhitespace(wchar_t c);
+bool IsUnicodeWhitespace(wchar_t c);
// Return a byte string in human-readable format with a unit suffix. Not
// 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_EXPORT string16 FormatBytesUnlocalized(int64_t bytes);
+string16 FormatBytesUnlocalized(int64_t bytes);
// Starting at |start_offset| (usually 0), replace the first instance of
// |find_this| with |replace_with|.
-BASE_EXPORT void ReplaceFirstSubstringAfterOffset(
+void ReplaceFirstSubstringAfterOffset(
base::string16* str,
size_t start_offset,
StringPiece16 find_this,
StringPiece16 replace_with);
-BASE_EXPORT void ReplaceFirstSubstringAfterOffset(
+void ReplaceFirstSubstringAfterOffset(
std::string* str,
size_t start_offset,
StringPiece find_this,
@@ -376,12 +375,12 @@
// This does entire substrings; use std::replace in <algorithm> for single
// characters, for example:
// std::replace(str.begin(), str.end(), 'a', 'b');
-BASE_EXPORT void ReplaceSubstringsAfterOffset(
+void ReplaceSubstringsAfterOffset(
string16* str,
size_t start_offset,
StringPiece16 find_this,
StringPiece16 replace_with);
-BASE_EXPORT void ReplaceSubstringsAfterOffset(
+void ReplaceSubstringsAfterOffset(
std::string* str,
size_t start_offset,
StringPiece find_this,
@@ -407,8 +406,8 @@
// of the string, and not doing that will mean people who access |str| rather
// than str.c_str() will get back a string of whatever size |str| had on entry
// to this function (probably 0).
-BASE_EXPORT char* WriteInto(std::string* str, size_t length_with_null);
-BASE_EXPORT char16* WriteInto(string16* str, size_t length_with_null);
+char* WriteInto(std::string* str, size_t length_with_null);
+char16* WriteInto(string16* str, size_t length_with_null);
// Does the opposite of SplitString()/SplitStringPiece(). Joins a vector or list
// of strings into a single string, inserting |separator| (which may be empty)
@@ -421,38 +420,38 @@
// copies of those strings are created until the final join operation.
//
// Use StrCat (in base/strings/strcat.h) if you don't need a separator.
-BASE_EXPORT std::string JoinString(const std::vector<std::string>& parts,
+std::string JoinString(const std::vector<std::string>& parts,
StringPiece separator);
-BASE_EXPORT string16 JoinString(const std::vector<string16>& parts,
+string16 JoinString(const std::vector<string16>& parts,
StringPiece16 separator);
-BASE_EXPORT std::string JoinString(const std::vector<StringPiece>& parts,
+std::string JoinString(const std::vector<StringPiece>& parts,
StringPiece separator);
-BASE_EXPORT string16 JoinString(const std::vector<StringPiece16>& parts,
+string16 JoinString(const std::vector<StringPiece16>& parts,
StringPiece16 separator);
// Explicit initializer_list overloads are required to break ambiguity when used
// with a literal initializer list (otherwise the compiler would not be able to
// decide between the string and StringPiece overloads).
-BASE_EXPORT std::string JoinString(std::initializer_list<StringPiece> parts,
+std::string JoinString(std::initializer_list<StringPiece> parts,
StringPiece separator);
-BASE_EXPORT string16 JoinString(std::initializer_list<StringPiece16> parts,
+string16 JoinString(std::initializer_list<StringPiece16> parts,
StringPiece16 separator);
// Replace $1-$2-$3..$9 in the format string with values from |subst|.
// 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_EXPORT string16 ReplaceStringPlaceholders(
+string16 ReplaceStringPlaceholders(
const string16& format_string,
const std::vector<string16>& subst,
std::vector<size_t>* offsets);
-BASE_EXPORT std::string ReplaceStringPlaceholders(
+std::string ReplaceStringPlaceholders(
StringPiece format_string,
const std::vector<std::string>& subst,
std::vector<size_t>* offsets);
// Single-string shortcut for ReplaceStringHolders. |offset| may be NULL.
-BASE_EXPORT string16 ReplaceStringPlaceholders(const string16& format_string,
+string16 ReplaceStringPlaceholders(const string16& format_string,
const string16& a,
size_t* offset);
diff --git a/base/strings/stringprintf.h b/base/strings/stringprintf.h
index 83969bb..e45bef3 100644
--- a/base/strings/stringprintf.h
+++ b/base/strings/stringprintf.h
@@ -9,54 +9,53 @@
#include <string>
-#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "build_config.h"
namespace base {
// Return a C++ string given printf-like input.
-BASE_EXPORT std::string StringPrintf(_Printf_format_string_ const char* format,
+std::string StringPrintf(_Printf_format_string_ const char* format,
...)
PRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
#if defined(OS_WIN)
-BASE_EXPORT std::wstring StringPrintf(
+std::wstring StringPrintf(
_Printf_format_string_ const wchar_t* format,
...) WPRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
#endif
// Return a C++ string given vprintf-like input.
-BASE_EXPORT std::string StringPrintV(const char* format, va_list ap)
+std::string StringPrintV(const char* format, va_list ap)
PRINTF_FORMAT(1, 0) WARN_UNUSED_RESULT;
// Store result into a supplied string and return it.
-BASE_EXPORT const std::string& SStringPrintf(
+const std::string& SStringPrintf(
std::string* dst,
_Printf_format_string_ const char* format,
...) PRINTF_FORMAT(2, 3);
#if defined(OS_WIN)
-BASE_EXPORT const std::wstring& SStringPrintf(
+const std::wstring& SStringPrintf(
std::wstring* dst,
_Printf_format_string_ const wchar_t* format,
...) WPRINTF_FORMAT(2, 3);
#endif
// Append result to a supplied string.
-BASE_EXPORT void StringAppendF(std::string* dst,
+void StringAppendF(std::string* dst,
_Printf_format_string_ const char* format,
...) PRINTF_FORMAT(2, 3);
#if defined(OS_WIN)
-BASE_EXPORT void StringAppendF(std::wstring* dst,
+void StringAppendF(std::wstring* dst,
_Printf_format_string_ const wchar_t* format,
...) WPRINTF_FORMAT(2, 3);
#endif
// Lower-level routine that takes a va_list and appends to a specified
// string. All other routines are just convenience wrappers around it.
-BASE_EXPORT void StringAppendV(std::string* dst, const char* format, va_list ap)
+void StringAppendV(std::string* dst, const char* format, va_list ap)
PRINTF_FORMAT(2, 0);
#if defined(OS_WIN)
-BASE_EXPORT void StringAppendV(std::wstring* dst,
+void StringAppendV(std::wstring* dst,
const wchar_t* format, va_list ap)
WPRINTF_FORMAT(2, 0);
#endif
diff --git a/base/strings/sys_string_conversions.h b/base/strings/sys_string_conversions.h
index 875cafb..096840b 100644
--- a/base/strings/sys_string_conversions.h
+++ b/base/strings/sys_string_conversions.h
@@ -13,7 +13,6 @@
#include <string>
-#include "base/base_export.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
#include "build_config.h"
@@ -31,14 +30,14 @@
// Converts between wide and UTF-8 representations of a string. On error, the
// result is system-dependent.
-BASE_EXPORT std::string SysWideToUTF8(const std::wstring& wide);
-BASE_EXPORT std::wstring SysUTF8ToWide(StringPiece utf8);
+std::string SysWideToUTF8(const std::wstring& wide);
+std::wstring SysUTF8ToWide(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_EXPORT std::string SysWideToNativeMB(const std::wstring& wide);
-BASE_EXPORT std::wstring SysNativeMBToWide(StringPiece native_mb);
+std::string SysWideToNativeMB(const std::wstring& wide);
+std::wstring SysNativeMBToWide(StringPiece native_mb);
// Windows-specific ------------------------------------------------------------
@@ -47,8 +46,8 @@
// 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_EXPORT std::wstring SysMultiByteToWide(StringPiece mb, uint32_t code_page);
-BASE_EXPORT std::string SysWideToMultiByte(const std::wstring& wide,
+std::wstring SysMultiByteToWide(StringPiece mb, uint32_t code_page);
+std::string SysWideToMultiByte(const std::wstring& wide,
uint32_t code_page);
#endif // defined(OS_WIN)
@@ -61,21 +60,21 @@
// Creates a string, and returns it with a refcount of 1. You are responsible
// for releasing it. Returns NULL on failure.
-BASE_EXPORT CFStringRef SysUTF8ToCFStringRef(const std::string& utf8);
-BASE_EXPORT CFStringRef SysUTF16ToCFStringRef(const string16& utf16);
+CFStringRef SysUTF8ToCFStringRef(const std::string& utf8);
+CFStringRef SysUTF16ToCFStringRef(const string16& utf16);
// Same, but returns an autoreleased NSString.
-BASE_EXPORT NSString* SysUTF8ToNSString(const std::string& utf8);
-BASE_EXPORT NSString* SysUTF16ToNSString(const string16& utf16);
+NSString* SysUTF8ToNSString(const std::string& utf8);
+NSString* SysUTF16ToNSString(const string16& utf16);
// Converts a CFStringRef to an STL string. Returns an empty string on failure.
-BASE_EXPORT std::string SysCFStringRefToUTF8(CFStringRef ref);
-BASE_EXPORT string16 SysCFStringRefToUTF16(CFStringRef ref);
+std::string SysCFStringRefToUTF8(CFStringRef ref);
+string16 SysCFStringRefToUTF16(CFStringRef ref);
// Same, but accepts NSString input. Converts nil NSString* to the appropriate
// string type of length 0.
-BASE_EXPORT std::string SysNSStringToUTF8(NSString* ref);
-BASE_EXPORT string16 SysNSStringToUTF16(NSString* ref);
+std::string SysNSStringToUTF8(NSString* ref);
+string16 SysNSStringToUTF16(NSString* ref);
#endif // defined(OS_MACOSX)
diff --git a/base/strings/utf_offset_string_conversions.h b/base/strings/utf_offset_string_conversions.h
index f741955..fdd012b 100644
--- a/base/strings/utf_offset_string_conversions.h
+++ b/base/strings/utf_offset_string_conversions.h
@@ -10,7 +10,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
@@ -20,9 +19,9 @@
// string in response to various adjustments one might do to that string
// (e.g., eliminating a range). For details on offsets, see the comments by
// the AdjustOffsets() function below.
-class BASE_EXPORT OffsetAdjuster {
+class OffsetAdjuster {
public:
- struct BASE_EXPORT Adjustment {
+ struct Adjustment {
Adjustment(size_t original_offset,
size_t original_length,
size_t output_length);
@@ -91,21 +90,21 @@
// Like the conversions in utf_string_conversions.h, but also fills in an
// |adjustments| parameter that reflects the alterations done to the string.
// It may be NULL.
-BASE_EXPORT bool UTF8ToUTF16WithAdjustments(
+bool UTF8ToUTF16WithAdjustments(
const char* src,
size_t src_len,
string16* output,
base::OffsetAdjuster::Adjustments* adjustments);
-BASE_EXPORT string16 UTF8ToUTF16WithAdjustments(
+string16 UTF8ToUTF16WithAdjustments(
const base::StringPiece& utf8,
base::OffsetAdjuster::Adjustments* adjustments);
// As above, but instead internally examines the adjustments and applies them
// to |offsets_for_adjustment|. Input offsets greater than the length of the
// input string will be set to string16::npos. See comments by AdjustOffsets().
-BASE_EXPORT string16 UTF8ToUTF16AndAdjustOffsets(
+string16 UTF8ToUTF16AndAdjustOffsets(
const base::StringPiece& utf8,
std::vector<size_t>* offsets_for_adjustment);
-BASE_EXPORT std::string UTF16ToUTF8AndAdjustOffsets(
+std::string UTF16ToUTF8AndAdjustOffsets(
const base::StringPiece16& utf16,
std::vector<size_t>* offsets_for_adjustment);
diff --git a/base/strings/utf_string_conversion_utils.h b/base/strings/utf_string_conversion_utils.h
index 2d95870..1712cee 100644
--- a/base/strings/utf_string_conversion_utils.h
+++ b/base/strings/utf_string_conversion_utils.h
@@ -11,7 +11,6 @@
#include <stddef.h>
#include <stdint.h>
-#include "base/base_export.h"
#include "base/strings/string16.h"
namespace base {
@@ -41,20 +40,20 @@
// (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_EXPORT bool ReadUnicodeCharacter(const char* src,
+bool ReadUnicodeCharacter(const char* src,
int32_t src_len,
int32_t* char_index,
uint32_t* code_point_out);
// Reads a UTF-16 character. The usage is the same as the 8-bit version above.
-BASE_EXPORT bool ReadUnicodeCharacter(const char16* src,
+bool ReadUnicodeCharacter(const char16* src,
int32_t src_len,
int32_t* char_index,
uint32_t* code_point);
#if defined(WCHAR_T_IS_UTF32)
// Reads UTF-32 character. The usage is the same as the 8-bit version above.
-BASE_EXPORT bool ReadUnicodeCharacter(const wchar_t* src,
+bool ReadUnicodeCharacter(const wchar_t* src,
int32_t src_len,
int32_t* char_index,
uint32_t* code_point);
@@ -64,12 +63,12 @@
// Appends a UTF-8 character to the given 8-bit string. Returns the number of
// bytes written.
-BASE_EXPORT size_t WriteUnicodeCharacter(uint32_t code_point,
+size_t WriteUnicodeCharacter(uint32_t 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.
-BASE_EXPORT size_t WriteUnicodeCharacter(uint32_t code_point, string16* output);
+size_t WriteUnicodeCharacter(uint32_t code_point, string16* output);
#if defined(WCHAR_T_IS_UTF32)
// Appends the given UTF-32 character to the given 32-bit string. Returns the
diff --git a/base/strings/utf_string_conversions.h b/base/strings/utf_string_conversions.h
index 14f94ac..45a4be3 100644
--- a/base/strings/utf_string_conversions.h
+++ b/base/strings/utf_string_conversions.h
@@ -9,7 +9,6 @@
#include <string>
-#include "base/base_export.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
@@ -21,33 +20,33 @@
// 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_EXPORT bool WideToUTF8(const wchar_t* src, size_t src_len,
+bool WideToUTF8(const wchar_t* src, size_t src_len,
std::string* output);
-BASE_EXPORT std::string WideToUTF8(WStringPiece wide);
-BASE_EXPORT bool UTF8ToWide(const char* src, size_t src_len,
+std::string WideToUTF8(WStringPiece wide);
+bool UTF8ToWide(const char* src, size_t src_len,
std::wstring* output);
-BASE_EXPORT std::wstring UTF8ToWide(StringPiece utf8);
+std::wstring UTF8ToWide(StringPiece utf8);
-BASE_EXPORT bool WideToUTF16(const wchar_t* src, size_t src_len,
+bool WideToUTF16(const wchar_t* src, size_t src_len,
string16* output);
-BASE_EXPORT string16 WideToUTF16(WStringPiece wide);
-BASE_EXPORT bool UTF16ToWide(const char16* src, size_t src_len,
+string16 WideToUTF16(WStringPiece wide);
+bool UTF16ToWide(const char16* src, size_t src_len,
std::wstring* output);
-BASE_EXPORT std::wstring UTF16ToWide(StringPiece16 utf16);
+std::wstring UTF16ToWide(StringPiece16 utf16);
-BASE_EXPORT bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
-BASE_EXPORT string16 UTF8ToUTF16(StringPiece utf8);
-BASE_EXPORT bool UTF16ToUTF8(const char16* src, size_t src_len,
+bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
+string16 UTF8ToUTF16(StringPiece utf8);
+bool UTF16ToUTF8(const char16* src, size_t src_len,
std::string* output);
-BASE_EXPORT std::string UTF16ToUTF8(StringPiece16 utf16);
+std::string UTF16ToUTF8(StringPiece16 utf16);
// This converts an ASCII string, typically a hardcoded constant, to a UTF16
// string.
-BASE_EXPORT string16 ASCIIToUTF16(StringPiece ascii);
+string16 ASCIIToUTF16(StringPiece ascii);
// Converts to 7-bit ASCII by truncating. The result must be known to be ASCII
// beforehand.
-BASE_EXPORT std::string UTF16ToASCII(StringPiece16 utf16);
+std::string UTF16ToASCII(StringPiece16 utf16);
} // namespace base
diff --git a/base/synchronization/condition_variable.h b/base/synchronization/condition_variable.h
index 6b5e56a..125bcb1 100644
--- a/base/synchronization/condition_variable.h
+++ b/base/synchronization/condition_variable.h
@@ -69,7 +69,6 @@
#include <pthread.h>
#endif
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/synchronization/lock.h"
@@ -83,7 +82,7 @@
class TimeDelta;
-class BASE_EXPORT ConditionVariable {
+class 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 f913a81..27e493c 100644
--- a/base/synchronization/lock.h
+++ b/base/synchronization/lock.h
@@ -5,7 +5,6 @@
#ifndef BASE_SYNCHRONIZATION_LOCK_H_
#define BASE_SYNCHRONIZATION_LOCK_H_
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/synchronization/lock_impl.h"
@@ -16,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_EXPORT Lock {
+class Lock {
public:
// Optimized wrapper implementation
Lock() : lock_() {}
diff --git a/base/synchronization/lock_impl.h b/base/synchronization/lock_impl.h
index e9da872..24ca09e 100644
--- a/base/synchronization/lock_impl.h
+++ b/base/synchronization/lock_impl.h
@@ -5,7 +5,6 @@
#ifndef BASE_SYNCHRONIZATION_LOCK_IMPL_H_
#define BASE_SYNCHRONIZATION_LOCK_IMPL_H_
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "build_config.h"
@@ -23,7 +22,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_EXPORT LockImpl {
+class LockImpl {
public:
#if defined(OS_WIN)
using NativeHandle = CHROME_SRWLOCK;
diff --git a/base/synchronization/waitable_event.h b/base/synchronization/waitable_event.h
index 64f5719..b4f713d 100644
--- a/base/synchronization/waitable_event.h
+++ b/base/synchronization/waitable_event.h
@@ -7,7 +7,6 @@
#include <stddef.h>
-#include "base/base_export.h"
#include "base/macros.h"
#include "build_config.h"
@@ -51,7 +50,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_EXPORT WaitableEvent {
+class WaitableEvent {
public:
// Indicates whether a WaitableEvent should automatically reset the event
// state after a single waiting thread has been released or remain signaled
diff --git a/base/threading/platform_thread.h b/base/threading/platform_thread.h
index c249bc2..6fbe327 100644
--- a/base/threading/platform_thread.h
+++ b/base/threading/platform_thread.h
@@ -11,7 +11,6 @@
#include <stddef.h>
-#include "base/base_export.h"
#include "base/macros.h"
#include "base/time/time.h"
#include "build_config.h"
@@ -100,11 +99,11 @@
const PlatformThreadId kInvalidThreadId(0);
// A namespace for low-level thread functions.
-class BASE_EXPORT PlatformThread {
+class 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_EXPORT Delegate {
+ class Delegate {
public:
virtual void ThreadMain() = 0;
diff --git a/base/time/clock.h b/base/time/clock.h
index 166cb2e..8f3a27f 100644
--- a/base/time/clock.h
+++ b/base/time/clock.h
@@ -5,7 +5,6 @@
#ifndef BASE_TIME_CLOCK_H_
#define BASE_TIME_CLOCK_H_
-#include "base/base_export.h"
#include "base/time/time.h"
namespace base {
@@ -25,7 +24,7 @@
//
// See TickClock (base/time/tick_clock.h) for the equivalent interface for
// TimeTicks.
-class BASE_EXPORT Clock {
+class Clock {
public:
virtual ~Clock();
diff --git a/base/time/time.h b/base/time/time.h
index eef95f3..931cf27 100644
--- a/base/time/time.h
+++ b/base/time/time.h
@@ -57,7 +57,6 @@
#include <iosfwd>
#include <limits>
-#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/numerics/safe_math.h"
@@ -91,14 +90,14 @@
// Add or subtract |value| from a TimeDelta. The int64_t argument and return
// value are in terms of a microsecond timebase.
-BASE_EXPORT int64_t SaturatedAdd(TimeDelta delta, int64_t value);
-BASE_EXPORT int64_t SaturatedSub(TimeDelta delta, int64_t value);
+int64_t SaturatedAdd(TimeDelta delta, int64_t value);
+int64_t SaturatedSub(TimeDelta delta, int64_t value);
} // namespace time_internal
// TimeDelta ------------------------------------------------------------------
-class BASE_EXPORT TimeDelta {
+class TimeDelta {
public:
constexpr TimeDelta() : delta_(0) {}
@@ -305,7 +304,7 @@
}
// For logging use only.
-BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeDelta time_delta);
+std::ostream& operator<<(std::ostream& os, TimeDelta time_delta);
// Do not reference the time_internal::TimeBase template class directly. Please
// use one of the time subclasses instead, and only reference the public
@@ -440,7 +439,7 @@
// Represents a wall clock time in UTC. Values are not guaranteed to be
// monotonically non-decreasing and are subject to large amounts of skew.
-class BASE_EXPORT Time : public time_internal::TimeBase<Time> {
+class Time : public time_internal::TimeBase<Time> {
public:
// Offset of UNIX epoch (1970-01-01 00:00:00 UTC) from Windows FILETIME epoch
// (1601-01-01 00:00:00 UTC), in microseconds. This value is derived from the
@@ -478,7 +477,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_EXPORT Exploded {
+ struct 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.)
@@ -757,12 +756,12 @@
}
// For logging use only.
-BASE_EXPORT std::ostream& operator<<(std::ostream& os, Time time);
+std::ostream& operator<<(std::ostream& os, Time time);
// TimeTicks ------------------------------------------------------------------
// Represents monotonically non-decreasing clock time.
-class BASE_EXPORT TimeTicks : public time_internal::TimeBase<TimeTicks> {
+class TimeTicks : public time_internal::TimeBase<TimeTicks> {
public:
// The underlying clock used to generate new TimeTicks.
enum class Clock {
@@ -847,13 +846,13 @@
};
// For logging use only.
-BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks);
+std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks);
// ThreadTicks ----------------------------------------------------------------
// Represents a clock, specific to a particular thread, than runs only while the
// thread is running.
-class BASE_EXPORT ThreadTicks : public time_internal::TimeBase<ThreadTicks> {
+class ThreadTicks : public time_internal::TimeBase<ThreadTicks> {
public:
ThreadTicks() : TimeBase(0) {
}
@@ -925,7 +924,7 @@
};
// For logging use only.
-BASE_EXPORT std::ostream& operator<<(std::ostream& os, ThreadTicks time_ticks);
+std::ostream& operator<<(std::ostream& os, ThreadTicks time_ticks);
} // namespace base
diff --git a/base/time/time_override.h b/base/time/time_override.h
index 1586a87..4e068f7 100644
--- a/base/time/time_override.h
+++ b/base/time/time_override.h
@@ -5,7 +5,6 @@
#ifndef BASE_TIME_TIME_OVERRIDE_H_
#define BASE_TIME_TIME_OVERRIDE_H_
-#include "base/base_export.h"
#include "base/time/time.h"
namespace base {
@@ -23,7 +22,7 @@
// modify progression of time. Note that the override should be set while
// single-threaded and before the first call to Now() to avoid threading issues
// and inconsistencies in returned values. Nested overrides are not allowed.
-class BASE_EXPORT ScopedTimeClockOverrides {
+class ScopedTimeClockOverrides {
public:
// Pass |nullptr| for any override if it shouldn't be overriden.
ScopedTimeClockOverrides(TimeNowFunction time_override,
@@ -46,10 +45,10 @@
// should only be used in places where emulated time should be disregarded. For
// example, they can be used to implement test timeouts for tests that may
// override time.
-BASE_EXPORT Time TimeNowIgnoringOverride();
-BASE_EXPORT Time TimeNowFromSystemTimeIgnoringOverride();
-BASE_EXPORT TimeTicks TimeTicksNowIgnoringOverride();
-BASE_EXPORT ThreadTicks ThreadTicksNowIgnoringOverride();
+Time TimeNowIgnoringOverride();
+Time TimeNowFromSystemTimeIgnoringOverride();
+TimeTicks TimeTicksNowIgnoringOverride();
+ThreadTicks ThreadTicksNowIgnoringOverride();
} // namespace subtle
diff --git a/base/timer/elapsed_timer.h b/base/timer/elapsed_timer.h
index 9dfa12c..c9d254b 100644
--- a/base/timer/elapsed_timer.h
+++ b/base/timer/elapsed_timer.h
@@ -5,14 +5,13 @@
#ifndef BASE_TIMER_ELAPSED_TIMER_H_
#define BASE_TIMER_ELAPSED_TIMER_H_
-#include "base/base_export.h"
#include "base/macros.h"
#include "base/time/time.h"
namespace base {
// A simple wrapper around TimeTicks::Now().
-class BASE_EXPORT ElapsedTimer {
+class ElapsedTimer {
public:
ElapsedTimer();
ElapsedTimer(ElapsedTimer&& other);
diff --git a/base/value_iterators.h b/base/value_iterators.h
index 2e05127..878ae7b 100644
--- a/base/value_iterators.h
+++ b/base/value_iterators.h
@@ -9,7 +9,6 @@
#include <string>
#include <utility>
-#include "base/base_export.h"
#include "base/containers/flat_map.h"
#include "base/macros.h"
@@ -26,7 +25,7 @@
// value_type is std::pair<const std::string, Value>. It's reference type is a
// std::pair<const std::string&, Value&>, so that callers have read-write
// access without incurring a copy.
-class BASE_EXPORT dict_iterator {
+class dict_iterator {
public:
using difference_type = DictStorage::iterator::difference_type;
using value_type = std::pair<const std::string, Value>;
@@ -58,9 +57,9 @@
dict_iterator& operator--();
dict_iterator operator--(int);
- BASE_EXPORT friend bool operator==(const dict_iterator& lhs,
+ friend bool operator==(const dict_iterator& lhs,
const dict_iterator& rhs);
- BASE_EXPORT friend bool operator!=(const dict_iterator& lhs,
+ friend bool operator!=(const dict_iterator& lhs,
const dict_iterator& rhs);
private:
@@ -72,7 +71,7 @@
// value_type is std::pair<const std::string, Value>. It's reference type is a
// std::pair<const std::string&, const Value&>, so that callers have read-only
// access without incurring a copy.
-class BASE_EXPORT const_dict_iterator {
+class const_dict_iterator {
public:
using difference_type = DictStorage::const_iterator::difference_type;
using value_type = std::pair<const std::string, Value>;
@@ -104,9 +103,9 @@
const_dict_iterator& operator--();
const_dict_iterator operator--(int);
- BASE_EXPORT friend bool operator==(const const_dict_iterator& lhs,
+ friend bool operator==(const const_dict_iterator& lhs,
const const_dict_iterator& rhs);
- BASE_EXPORT friend bool operator!=(const const_dict_iterator& lhs,
+ friend bool operator!=(const const_dict_iterator& lhs,
const const_dict_iterator& rhs);
private:
@@ -118,7 +117,7 @@
// to use this class for easy iteration over the underlying values, granting
// them either read-only or read-write access, depending on the
// const-qualification.
-class BASE_EXPORT dict_iterator_proxy {
+class dict_iterator_proxy {
public:
using key_type = DictStorage::key_type;
using mapped_type = DictStorage::mapped_type::element_type;
@@ -157,7 +156,7 @@
// underlying DictStorage in const_dict_iterators. This allows callers to use
// this class for easy iteration over the underlying values, granting them
// either read-only access.
-class BASE_EXPORT const_dict_iterator_proxy {
+class const_dict_iterator_proxy {
public:
using key_type = const DictStorage::key_type;
using mapped_type = const DictStorage::mapped_type::element_type;
diff --git a/base/values.h b/base/values.h
index 01769a5..99e00c5 100644
--- a/base/values.h
+++ b/base/values.h
@@ -30,7 +30,6 @@
#include <utility>
#include <vector>
-#include "base/base_export.h"
#include "base/containers/flat_map.h"
#include "base/containers/span.h"
#include "base/macros.h"
@@ -77,7 +76,7 @@
// dict.SetKey("mykey", base::Value(foo));
// return dict;
// }
-class BASE_EXPORT Value {
+class Value {
public:
using BlobStorage = std::vector<char>;
using DictStorage = flat_map<std::string, std::unique_ptr<Value>>;
@@ -331,12 +330,12 @@
// Comparison operators so that Values can easily be used with standard
// library algorithms and associative containers.
- BASE_EXPORT friend bool operator==(const Value& lhs, const Value& rhs);
- BASE_EXPORT friend bool operator!=(const Value& lhs, const Value& rhs);
- BASE_EXPORT friend bool operator<(const Value& lhs, const Value& rhs);
- BASE_EXPORT friend bool operator>(const Value& lhs, const Value& rhs);
- BASE_EXPORT friend bool operator<=(const Value& lhs, const Value& rhs);
- BASE_EXPORT friend bool operator>=(const Value& lhs, const Value& rhs);
+ friend bool operator==(const Value& lhs, const Value& rhs);
+ friend bool operator!=(const Value& lhs, const Value& rhs);
+ friend bool operator<(const Value& lhs, const Value& rhs);
+ friend bool operator>(const Value& lhs, const Value& rhs);
+ friend bool operator<=(const Value& lhs, const Value& rhs);
+ friend bool operator>=(const Value& lhs, const Value& rhs);
// Compares if two Value objects have equal contents.
// DEPRECATED, use operator==(const Value& lhs, const Value& rhs) instead.
@@ -371,7 +370,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_EXPORT DictionaryValue : public Value {
+class DictionaryValue : public Value {
public:
using const_iterator = DictStorage::const_iterator;
using iterator = DictStorage::iterator;
@@ -538,7 +537,7 @@
// This class provides an iterator over both keys and values in the
// dictionary. It can't be used to modify the dictionary.
// DEPRECATED, use Value::DictItems() instead.
- class BASE_EXPORT Iterator {
+ class Iterator {
public:
explicit Iterator(const DictionaryValue& target);
Iterator(const Iterator& other);
@@ -573,7 +572,7 @@
};
// This type of Value represents a list of other Value values.
-class BASE_EXPORT ListValue : public Value {
+class ListValue : public Value {
public:
using const_iterator = ListStorage::const_iterator;
using iterator = ListStorage::iterator;
@@ -713,7 +712,7 @@
// This interface is implemented by classes that know how to serialize
// Value objects.
-class BASE_EXPORT ValueSerializer {
+class ValueSerializer {
public:
virtual ~ValueSerializer();
@@ -722,7 +721,7 @@
// This interface is implemented by classes that know how to deserialize Value
// objects.
-class BASE_EXPORT ValueDeserializer {
+class ValueDeserializer {
public:
virtual ~ValueDeserializer();
@@ -740,20 +739,20 @@
// gtest uses this operator to print readable output on test failures, we must
// override each specific type. Otherwise, the default template implementation
// is preferred over an upcast.
-BASE_EXPORT std::ostream& operator<<(std::ostream& out, const Value& value);
+std::ostream& operator<<(std::ostream& out, const Value& value);
-BASE_EXPORT inline std::ostream& operator<<(std::ostream& out,
+inline std::ostream& operator<<(std::ostream& out,
const DictionaryValue& value) {
return out << static_cast<const Value&>(value);
}
-BASE_EXPORT inline std::ostream& operator<<(std::ostream& out,
+inline std::ostream& operator<<(std::ostream& out,
const ListValue& value) {
return out << static_cast<const Value&>(value);
}
// Stream operator so that enum class Types can be used in log statements.
-BASE_EXPORT std::ostream& operator<<(std::ostream& out,
+std::ostream& operator<<(std::ostream& out,
const Value::Type& type);
} // namespace base
diff --git a/base/win/com_init_check_hook.h b/base/win/com_init_check_hook.h
index 3f1fbcd..6681da1 100644
--- a/base/win/com_init_check_hook.h
+++ b/base/win/com_init_check_hook.h
@@ -5,7 +5,6 @@
#ifndef BASE_WIN_COM_INIT_CHECK_HOOK_H_
#define BASE_WIN_COM_INIT_CHECK_HOOK_H_
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "build_config.h"
@@ -28,7 +27,7 @@
// COM to be initialized and only works if COM_INIT_CHECK_HOOK_ENABLED is
// defined. Care should be taken if this is instantiated with multiple threads
// running as the hotpatch does not apply atomically.
-class BASE_EXPORT ComInitCheckHook {
+class ComInitCheckHook {
public:
ComInitCheckHook();
~ComInitCheckHook();
diff --git a/base/win/com_init_util.h b/base/win/com_init_util.h
index be5a1b4..9d47099 100644
--- a/base/win/com_init_util.h
+++ b/base/win/com_init_util.h
@@ -5,7 +5,6 @@
#ifndef BASE_WIN_COM_INIT_UTIL_H_
#define BASE_WIN_COM_INIT_UTIL_H_
-#include "base/base_export.h"
#include "base/logging.h"
namespace base {
@@ -24,11 +23,11 @@
// DCHECKs if COM is not initialized on this thread as an STA or MTA.
// |message| is optional and is used for the DCHECK if specified.
-BASE_EXPORT void AssertComInitialized(const char* message = nullptr);
+void AssertComInitialized(const char* message = nullptr);
// DCHECKs if |apartment_type| is not the same as the current thread's apartment
// type.
-BASE_EXPORT void AssertComApartmentType(ComApartmentType apartment_type);
+void AssertComApartmentType(ComApartmentType apartment_type);
#else // DCHECK_IS_ON()
inline void AssertComInitialized() {}
diff --git a/base/win/core_winrt_util.h b/base/win/core_winrt_util.h
index c86aed6..4698f78 100644
--- a/base/win/core_winrt_util.h
+++ b/base/win/core_winrt_util.h
@@ -10,7 +10,6 @@
#include <roapi.h>
#include <windef.h>
-#include "base/base_export.h"
#include "base/strings/string16.h"
#include "base/win/scoped_hstring.h"
@@ -21,20 +20,20 @@
// Windows 7. Loads functions dynamically at runtime to prevent library
// dependencies.
-BASE_EXPORT bool ResolveCoreWinRTDelayload();
+bool ResolveCoreWinRTDelayload();
// The following stubs are provided for when component build is enabled, in
// order to avoid the propagation of delay-loading CoreWinRT to other modules.
-BASE_EXPORT HRESULT RoInitialize(RO_INIT_TYPE init_type);
+HRESULT RoInitialize(RO_INIT_TYPE init_type);
-BASE_EXPORT void RoUninitialize();
+void RoUninitialize();
-BASE_EXPORT HRESULT RoGetActivationFactory(HSTRING class_id,
+HRESULT RoGetActivationFactory(HSTRING class_id,
const IID& iid,
void** out_factory);
-BASE_EXPORT HRESULT RoActivateInstance(HSTRING class_id,
+HRESULT RoActivateInstance(HSTRING class_id,
IInspectable** instance);
// Retrieves an activation factory for the type specified.
diff --git a/base/win/enum_variant.h b/base/win/enum_variant.h
index e27afcd..b61fc8f 100644
--- a/base/win/enum_variant.h
+++ b/base/win/enum_variant.h
@@ -15,7 +15,7 @@
namespace win {
// A simple implementation of IEnumVARIANT.
-class BASE_EXPORT EnumVariant
+class EnumVariant
: public IEnumVARIANT,
public IUnknownImpl {
public:
diff --git a/base/win/event_trace_controller.h b/base/win/event_trace_controller.h
index 2e32b4c..17b82bc 100644
--- a/base/win/event_trace_controller.h
+++ b/base/win/event_trace_controller.h
@@ -26,7 +26,6 @@
#include <stddef.h>
#include <string>
-#include "base/base_export.h"
#include "base/macros.h"
namespace base {
@@ -35,7 +34,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_EXPORT EtwTraceProperties {
+class EtwTraceProperties {
public:
EtwTraceProperties();
@@ -85,7 +84,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_EXPORT EtwTraceController {
+class EtwTraceController {
public:
EtwTraceController();
~EtwTraceController();
diff --git a/base/win/event_trace_provider.h b/base/win/event_trace_provider.h
index d550dd6..321f539 100644
--- a/base/win/event_trace_provider.h
+++ b/base/win/event_trace_provider.h
@@ -15,7 +15,6 @@
#include <limits>
-#include "base/base_export.h"
#include "base/macros.h"
namespace base {
@@ -90,7 +89,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_EXPORT EtwTraceProvider {
+class 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/iat_patch_function.h b/base/win/iat_patch_function.h
index 86ad295..30f0ab9 100644
--- a/base/win/iat_patch_function.h
+++ b/base/win/iat_patch_function.h
@@ -7,7 +7,6 @@
#include <windows.h>
-#include "base/base_export.h"
#include "base/macros.h"
namespace base {
@@ -20,7 +19,7 @@
// This is the case when, for example, we want to intercept
// CertDuplicateCertificateContext function (exported from crypt32.dll) called
// by wininet.dll.
-class BASE_EXPORT IATPatchFunction {
+class IATPatchFunction {
public:
IATPatchFunction();
~IATPatchFunction();
diff --git a/base/win/iunknown_impl.h b/base/win/iunknown_impl.h
index b7de205..60f2403 100644
--- a/base/win/iunknown_impl.h
+++ b/base/win/iunknown_impl.h
@@ -8,14 +8,13 @@
#include <unknwn.h>
#include "base/atomic_ref_count.h"
-#include "base/base_export.h"
#include "base/compiler_specific.h"
namespace base {
namespace win {
// IUnknown implementation for other classes to derive from.
-class BASE_EXPORT IUnknownImpl : public IUnknown {
+class IUnknownImpl : public IUnknown {
public:
IUnknownImpl();
diff --git a/base/win/patch_util.h b/base/win/patch_util.h
index 035fb83..02ac72c 100644
--- a/base/win/patch_util.h
+++ b/base/win/patch_util.h
@@ -7,7 +7,6 @@
#include <windows.h>
-#include "base/base_export.h"
namespace base {
namespace win {
@@ -16,7 +15,7 @@
// Copies |length| bytes from |source| to |destination|, temporarily setting
// |destination| to writable. Returns a Windows error code or NO_ERROR if
// successful.
-BASE_EXPORT DWORD ModifyCode(void* destination, const void* source, int length);
+DWORD ModifyCode(void* destination, const void* source, int length);
} // namespace internal
} // namespace win
diff --git a/base/win/process_startup_helper.h b/base/win/process_startup_helper.h
index f633dda..2f19ac9 100644
--- a/base/win/process_startup_helper.h
+++ b/base/win/process_startup_helper.h
@@ -5,7 +5,6 @@
#ifndef BASE_WIN_PROCESS_STARTUP_HELPER_H_
#define BASE_WIN_PROCESS_STARTUP_HELPER_H_
-#include "base/base_export.h"
namespace base {
@@ -15,10 +14,10 @@
// Register the invalid param handler and pure call handler to be able to
// notify breakpad when it happens.
-BASE_EXPORT void RegisterInvalidParamHandler();
+void RegisterInvalidParamHandler();
// Sets up the CRT's debugging macros to output to stdout.
-BASE_EXPORT void SetupCRT(const CommandLine& command_line);
+void SetupCRT(const CommandLine& command_line);
} // namespace win
} // namespace base
diff --git a/base/win/registry.h b/base/win/registry.h
index db016bf..413ee7a 100644
--- a/base/win/registry.h
+++ b/base/win/registry.h
@@ -10,7 +10,6 @@
#include <vector>
#include "base/win/windows_types.h"
-#include "base/base_export.h"
#include "base/macros.h"
#include "base/win/scoped_handle.h"
@@ -26,7 +25,7 @@
// is not touched in case of failure.
// * Functions returning LONG indicate success as ERROR_SUCCESS or an
// error as a (non-zero) win32 error code.
-class BASE_EXPORT RegKey {
+class RegKey {
public:
RegKey();
explicit RegKey(HKEY key);
@@ -143,7 +142,7 @@
};
// Iterates the entries found in a particular folder on the registry.
-class BASE_EXPORT RegistryValueIterator {
+class RegistryValueIterator {
public:
// Constructs a Registry Value Iterator with default WOW64 access.
RegistryValueIterator(HKEY root_key, const wchar_t* folder_key);
@@ -196,7 +195,7 @@
DISALLOW_COPY_AND_ASSIGN(RegistryValueIterator);
};
-class BASE_EXPORT RegistryKeyIterator {
+class RegistryKeyIterator {
public:
// Constructs a Registry Key Iterator with default WOW64 access.
RegistryKeyIterator(HKEY root_key, const wchar_t* folder_key);
diff --git a/base/win/resource_util.h b/base/win/resource_util.h
index 00687b9..3e6b145 100644
--- a/base/win/resource_util.h
+++ b/base/win/resource_util.h
@@ -11,7 +11,6 @@
#include <windows.h>
#include <stddef.h>
-#include "base/base_export.h"
namespace base {
namespace win {
@@ -19,7 +18,7 @@
// Function for getting a data resource of the specified |resource_type| 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_EXPORT GetResourceFromModule(HMODULE module,
+bool GetResourceFromModule(HMODULE module,
int resource_id,
LPCTSTR resource_type,
void** data,
@@ -28,7 +27,7 @@
// 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_EXPORT GetDataResourceFromModule(HMODULE module,
+bool GetDataResourceFromModule(HMODULE module,
int resource_id,
void** data,
size_t* length);
diff --git a/base/win/scoped_bstr.h b/base/win/scoped_bstr.h
index 2109c20..02f73ed 100644
--- a/base/win/scoped_bstr.h
+++ b/base/win/scoped_bstr.h
@@ -9,7 +9,6 @@
#include <oleauto.h>
#include <stddef.h>
-#include "base/base_export.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/strings/string16.h"
@@ -19,7 +18,7 @@
// Manages a BSTR string pointer.
// The class interface is based on unique_ptr.
-class BASE_EXPORT ScopedBstr {
+class ScopedBstr {
public:
ScopedBstr() : bstr_(NULL) {
}
diff --git a/base/win/scoped_handle.h b/base/win/scoped_handle.h
index 010e8a4..7c63bb7 100644
--- a/base/win/scoped_handle.h
+++ b/base/win/scoped_handle.h
@@ -7,7 +7,6 @@
#include "base/win/windows_types.h"
-#include "base/base_export.h"
#include "base/gtest_prod_util.h"
#include "base/logging.h"
#include "base/macros.h"
@@ -111,7 +110,7 @@
typedef HANDLE Handle;
// Closes the handle.
- static bool BASE_EXPORT CloseHandle(HANDLE handle);
+ static bool CloseHandle(HANDLE handle);
// Returns true if the handle value is valid.
static bool IsHandleValid(HANDLE handle) {
@@ -142,7 +141,7 @@
};
// Performs actual run-time tracking.
-class BASE_EXPORT VerifierTraits {
+class VerifierTraits {
public:
typedef HANDLE Handle;
@@ -160,13 +159,13 @@
// This function may be called by the embedder to disable the use of
// VerifierTraits at runtime. It has no effect if DummyVerifierTraits is used
// for ScopedHandle.
-BASE_EXPORT void DisableHandleVerifier();
+void DisableHandleVerifier();
// This should be called whenever the OS is closing a handle, if extended
// verification of improper handle closing is desired. If |handle| is being
// tracked by the handle verifier and ScopedHandle is not the one closing it,
// a CHECK is generated.
-BASE_EXPORT void OnHandleBeingClosed(HANDLE handle);
+void OnHandleBeingClosed(HANDLE handle);
} // namespace win
} // namespace base
diff --git a/base/win/scoped_hstring.h b/base/win/scoped_hstring.h
index 6ba1dab..7c169b9 100644
--- a/base/win/scoped_hstring.h
+++ b/base/win/scoped_hstring.h
@@ -16,7 +16,7 @@
// Scoped HSTRING class to maintain lifetime of HSTRINGs allocated with
// WindowsCreateString().
-struct BASE_EXPORT ScopedHStringTraits {
+struct ScopedHStringTraits {
static HSTRING InvalidValue() { return nullptr; }
static void Free(HSTRING hstr);
};
@@ -51,7 +51,7 @@
// HRESULT hr = WindowsCreateString(..., &win_string);
// ScopedHString string(win_string);
//
-class BASE_EXPORT ScopedHString
+class ScopedHString
: public ScopedGeneric<HSTRING, base::internal::ScopedHStringTraits> {
public:
// Constructs a ScopedHString from an HSTRING, and takes ownership of |hstr|.
diff --git a/base/win/scoped_process_information.h b/base/win/scoped_process_information.h
index 01df861..ca76e21 100644
--- a/base/win/scoped_process_information.h
+++ b/base/win/scoped_process_information.h
@@ -7,7 +7,6 @@
#include <windows.h>
-#include "base/base_export.h"
#include "base/macros.h"
#include "base/win/scoped_handle.h"
@@ -16,7 +15,7 @@
// Manages the closing of process and thread handles from PROCESS_INFORMATION
// structures. Allows clients to take ownership of either handle independently.
-class BASE_EXPORT ScopedProcessInformation {
+class ScopedProcessInformation {
public:
ScopedProcessInformation();
explicit ScopedProcessInformation(const PROCESS_INFORMATION& process_info);
diff --git a/base/win/scoped_variant.h b/base/win/scoped_variant.h
index 81f4b2b..5390eb9 100644
--- a/base/win/scoped_variant.h
+++ b/base/win/scoped_variant.h
@@ -9,7 +9,6 @@
#include <oleauto.h>
#include <stdint.h>
-#include "base/base_export.h"
#include "base/macros.h"
namespace base {
@@ -21,7 +20,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_EXPORT ScopedVariant {
+class ScopedVariant {
public:
// Declaration of a global variant variable that's always VT_EMPTY
static const VARIANT kEmptyVariant;
diff --git a/base/win/shortcut.h b/base/win/shortcut.h
index 38c12b7..1ab0188 100644
--- a/base/win/shortcut.h
+++ b/base/win/shortcut.h
@@ -8,7 +8,6 @@
#include <windows.h>
#include <stdint.h>
-#include "base/base_export.h"
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/strings/string16.h"
@@ -31,7 +30,7 @@
// creation/update, others will be ignored.
// Callers are encouraged to use the setters provided which take care of
// setting |options| as desired.
-struct BASE_EXPORT ShortcutProperties {
+struct ShortcutProperties {
enum IndividualProperties {
PROPERTIES_TARGET = 1U << 0,
PROPERTIES_WORKING_DIR = 1U << 1,
@@ -131,7 +130,7 @@
// |operation|: a choice from the ShortcutOperation enum.
// If |operation| is SHORTCUT_REPLACE_EXISTING or SHORTCUT_UPDATE_EXISTING and
// |shortcut_path| does not exist, this method is a no-op and returns false.
-BASE_EXPORT bool CreateOrUpdateShortcutLink(
+bool CreateOrUpdateShortcutLink(
const FilePath& shortcut_path,
const ShortcutProperties& properties,
ShortcutOperation operation);
@@ -146,7 +145,7 @@
// path so it may not be valid. The function returns true if all requested
// properties are successfully read. Otherwise some reads have failed and
// intermediate values written to |properties| should be ignored.
-BASE_EXPORT bool ResolveShortcutProperties(const FilePath& shortcut_path,
+bool ResolveShortcutProperties(const FilePath& shortcut_path,
uint32_t options,
ShortcutProperties* properties);
@@ -157,23 +156,23 @@
// non-NULL). The function returns true if all requested fields are found
// successfully. Callers can safely use the same variable for both
// |shortcut_path| and |target_path|.
-BASE_EXPORT bool ResolveShortcut(const FilePath& shortcut_path,
+bool ResolveShortcut(const FilePath& shortcut_path,
FilePath* target_path,
string16* args);
// Pin to taskbar is only supported on Windows 7 and Windows 8. Returns true on
// those platforms.
-BASE_EXPORT bool CanPinShortcutToTaskbar();
+bool CanPinShortcutToTaskbar();
// Pins a shortcut to the taskbar on Windows 7 and 8. The |shortcut| file must
// already exist and be a shortcut that points to an executable. The app id of
// the shortcut is used to group windows and must be set correctly.
-BASE_EXPORT bool PinShortcutToTaskbar(const FilePath& shortcut);
+bool PinShortcutToTaskbar(const FilePath& shortcut);
// Unpins a shortcut from the Windows 7+ taskbar. The |shortcut| must exist and
// already be pinned to the taskbar. The app id of the shortcut is used as the
// identifier for the taskbar item to remove and must be set correctly.
-BASE_EXPORT bool UnpinShortcutFromTaskbar(const FilePath& shortcut);
+bool UnpinShortcutFromTaskbar(const FilePath& shortcut);
} // namespace win
} // namespace base
diff --git a/base/win/startup_information.h b/base/win/startup_information.h
index 5b777ba..f82ff75 100644
--- a/base/win/startup_information.h
+++ b/base/win/startup_information.h
@@ -8,14 +8,13 @@
#include <windows.h>
#include <stddef.h>
-#include "base/base_export.h"
#include "base/macros.h"
namespace base {
namespace win {
// Manages the lifetime of additional attributes in STARTUPINFOEX.
-class BASE_EXPORT StartupInformation {
+class StartupInformation {
public:
StartupInformation();
diff --git a/base/win/wait_chain.h b/base/win/wait_chain.h
index b2e19de..0b5947b 100644
--- a/base/win/wait_chain.h
+++ b/base/win/wait_chain.h
@@ -28,14 +28,14 @@
// the failure, given that they are not null.
// TODO(pmonette): Remove |failure_reason| and |last_error| when UMA is
// supported in the watcher process and pre-rendez-vous.
-BASE_EXPORT bool GetThreadWaitChain(DWORD thread_id,
+bool GetThreadWaitChain(DWORD thread_id,
WaitChainNodeVector* wait_chain,
bool* is_deadlock,
base::string16* failure_reason,
DWORD* last_error);
// Returns a string that represents the node for a wait chain.
-BASE_EXPORT base::string16 WaitChainNodeToString(
+base::string16 WaitChainNodeToString(
const WAITCHAIN_NODE_INFO& node);
} // namespace win
diff --git a/base/win/win_client_metrics.h b/base/win/win_client_metrics.h
index 102148f..d63bf20 100644
--- a/base/win/win_client_metrics.h
+++ b/base/win/win_client_metrics.h
@@ -33,7 +33,7 @@
namespace base {
namespace win {
-BASE_EXPORT void GetNonClientMetrics(NONCLIENTMETRICS_XP* metrics);
+void GetNonClientMetrics(NONCLIENTMETRICS_XP* metrics);
} // namespace win
} // namespace base
diff --git a/base/win/win_util.h b/base/win/win_util.h
index 3d8830b..1acd455 100644
--- a/base/win/win_util.h
+++ b/base/win/win_util.h
@@ -28,7 +28,6 @@
#include <string>
#include <vector>
-#include "base/base_export.h"
#include "base/strings/string16.h"
struct IPropertyStore;
@@ -52,7 +51,7 @@
}
// Returns the string representing the current user sid.
-BASE_EXPORT bool GetUserSidString(std::wstring* user_sid);
+bool GetUserSidString(std::wstring* user_sid);
// Returns false if user account control (UAC) has been disabled with the
// EnableLUA registry flag. Returns true if user account control is enabled.
@@ -60,42 +59,42 @@
// 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_EXPORT bool UserAccountControlIsEnabled();
+bool UserAccountControlIsEnabled();
// Sets the boolean value for a given key in given IPropertyStore.
-BASE_EXPORT bool SetBooleanValueForPropertyStore(
+bool SetBooleanValueForPropertyStore(
IPropertyStore* property_store,
const PROPERTYKEY& property_key,
bool property_bool_value);
// Sets the string value for a given key in given IPropertyStore.
-BASE_EXPORT bool SetStringValueForPropertyStore(
+bool SetStringValueForPropertyStore(
IPropertyStore* property_store,
const PROPERTYKEY& property_key,
const wchar_t* property_string_value);
// Sets the CLSID value for a given key in a given IPropertyStore.
-BASE_EXPORT bool SetClsidForPropertyStore(IPropertyStore* property_store,
+bool SetClsidForPropertyStore(IPropertyStore* property_store,
const PROPERTYKEY& property_key,
const CLSID& property_clsid_value);
// Sets the application id in given IPropertyStore. The function is intended
// for tagging application/chromium shortcut, browser window and jump list for
// Win7.
-BASE_EXPORT bool SetAppIdForPropertyStore(IPropertyStore* property_store,
+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_EXPORT bool AddCommandToAutoRun(HKEY root_key, const string16& name,
+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_EXPORT bool RemoveCommandFromAutoRun(HKEY root_key, const string16& name);
+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_EXPORT bool ReadCommandFromAutoRun(HKEY root_key,
+bool ReadCommandFromAutoRun(HKEY root_key,
const string16& name,
string16* command);
@@ -104,12 +103,12 @@
// exit(), abort(), _exit(), ExitProcess()) and convert them into crashes.
// Note that not all mechanisms for terminating the process are covered by
// this. In particular, TerminateProcess() is not caught.
-BASE_EXPORT void SetShouldCrashOnProcessDetach(bool crash);
-BASE_EXPORT bool ShouldCrashOnProcessDetach();
+void SetShouldCrashOnProcessDetach(bool crash);
+bool ShouldCrashOnProcessDetach();
// Adjusts the abort behavior so that crash reports can be generated when the
// process is aborted.
-BASE_EXPORT void SetAbortBehaviorForCrashReporting();
+void SetAbortBehaviorForCrashReporting();
// Get the size of a struct up to and including the specified member.
// This is necessary to set compatible struct sizes for different versions
@@ -120,33 +119,33 @@
// Used by tests to mock any wanted state. Call with |state| set to true to
// simulate being in a domain and false otherwise.
-BASE_EXPORT void SetDomainStateForTesting(bool state);
+void SetDomainStateForTesting(bool state);
// Returns true if the current process can make USER32 or GDI32 calls such as
// CreateWindow and CreateDC. Windows 8 and above allow the kernel component
// of these calls to be disabled which can cause undefined behaviour such as
// crashes. This function can be used to guard areas of code using these calls
// and provide a fallback path if necessary.
-BASE_EXPORT bool IsUser32AndGdi32Available();
+bool IsUser32AndGdi32Available();
// Takes a snapshot of the modules loaded in the |process|. The returned
// HMODULEs are not add-ref'd, so they should not be closed and may be
// invalidated at any time (should a module be unloaded). |process| requires
// the PROCESS_QUERY_INFORMATION and PROCESS_VM_READ permissions.
-BASE_EXPORT bool GetLoadedModulesSnapshot(HANDLE process,
+bool GetLoadedModulesSnapshot(HANDLE process,
std::vector<HMODULE>* snapshot);
// Adds or removes the MICROSOFT_TABLETPENSERVICE_PROPERTY property with the
// TABLET_DISABLE_FLICKS & TABLET_DISABLE_FLICKFALLBACKKEYS flags in order to
// disable pen flick gestures for the given HWND.
-BASE_EXPORT void EnableFlicks(HWND hwnd);
-BASE_EXPORT void DisableFlicks(HWND hwnd);
+void EnableFlicks(HWND hwnd);
+void DisableFlicks(HWND hwnd);
// Returns true if the process is per monitor DPI aware.
-BASE_EXPORT bool IsProcessPerMonitorDpiAware();
+bool IsProcessPerMonitorDpiAware();
// Enable high-DPI support for the current process.
-BASE_EXPORT void EnableHighDPISupport();
+void EnableHighDPISupport();
} // namespace win
} // namespace base
diff --git a/base/win/windows_version.h b/base/win/windows_version.h
index 28c7c89..cd1df78 100644
--- a/base/win/windows_version.h
+++ b/base/win/windows_version.h
@@ -9,7 +9,6 @@
#include <string>
-#include "base/base_export.h"
#include "base/macros.h"
typedef void* HANDLE;
@@ -59,7 +58,7 @@
// A singleton that can be used to query various pieces of information about the
// OS and process state. Note that this doesn't use the base Singleton class, so
// it can be used without an AtExitManager.
-class BASE_EXPORT OSInfo {
+class OSInfo {
public:
struct VersionNumber {
int major;
@@ -139,7 +138,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_EXPORT Version GetVersion();
+Version GetVersion();
} // namespace win
} // namespace base
diff --git a/base/win/winrt_storage_util.h b/base/win/winrt_storage_util.h
index e24336c..5578415 100644
--- a/base/win/winrt_storage_util.h
+++ b/base/win/winrt_storage_util.h
@@ -9,21 +9,20 @@
#include <windows.storage.streams.h>
#include <wrl/client.h>
-#include "base/base_export.h"
namespace base {
namespace win {
// Gets an array of bytes in the |buffer|, |out| represents a array of
// bytes used by byte stream read and write.
-BASE_EXPORT HRESULT
+HRESULT
GetPointerToBufferData(ABI::Windows::Storage::Streams::IBuffer* buffer,
uint8_t** out,
UINT32* length);
// Creates stream |buffer| from |data| that represents a array of bytes
// and the |length| of bytes.
-BASE_EXPORT HRESULT CreateIBufferFromData(
+HRESULT CreateIBufferFromData(
const uint8_t* data,
UINT32 length,
Microsoft::WRL::ComPtr<ABI::Windows::Storage::Streams::IBuffer>* buffer);
