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);