Rename base to butil to avoid potential naming conflicts

Makefile

@@ -14,7 +14,7 @@ LIBPATHS = $(addprefix -L, $(LIBS))
 SRCEXTS = .c .cc .cpp .proto
 HDREXTS = .h .hpp
 
-#required by base/crc32.cc to boost performance for 10x
+#required by butil/crc32.cc to boost performance for 10x
 ifeq ($(shell test $(GCC_VERSION) -ge 40400; echo $$?),0)
 	CXXFLAGS+=-msse4 -msse4.2
 endif
@@ -23,162 +23,162 @@ ifeq ($(shell test $(GCC_VERSION) -ge 70000; echo $$?),0)
 	CXXFLAGS+=-Wno-aligned-new
 endif
 
-BASE_SOURCES = \
-    src/base/third_party/dmg_fp/g_fmt.cc \
-    src/base/third_party/dmg_fp/dtoa_wrapper.cc \
-    src/base/third_party/dynamic_annotations/dynamic_annotations.c \
-    src/base/third_party/icu/icu_utf.cc \
-    src/base/third_party/superfasthash/superfasthash.c \
-    src/base/third_party/modp_b64/modp_b64.cc \
-    src/base/third_party/nspr/prtime.cc \
-    src/base/third_party/symbolize/demangle.cc \
-    src/base/third_party/symbolize/symbolize.cc \
-    src/base/third_party/xdg_mime/xdgmime.c \
-    src/base/third_party/xdg_mime/xdgmimealias.c \
-    src/base/third_party/xdg_mime/xdgmimecache.c \
-    src/base/third_party/xdg_mime/xdgmimeglob.c \
-    src/base/third_party/xdg_mime/xdgmimeicon.c \
-    src/base/third_party/xdg_mime/xdgmimeint.c \
-    src/base/third_party/xdg_mime/xdgmimemagic.c \
-    src/base/third_party/xdg_mime/xdgmimeparent.c \
-    src/base/third_party/xdg_user_dirs/xdg_user_dir_lookup.cc \
-    src/base/third_party/snappy/snappy-sinksource.cc \
-    src/base/third_party/snappy/snappy-stubs-internal.cc \
-    src/base/third_party/snappy/snappy.cc \
-    src/base/third_party/murmurhash3/murmurhash3.cpp \
-    src/base/allocator/type_profiler_control.cc \
-    src/base/arena.cpp \
-    src/base/at_exit.cc \
-    src/base/atomicops_internals_x86_gcc.cc \
-    src/base/barrier_closure.cc \
-    src/base/base_paths.cc \
-    src/base/base_paths_posix.cc \
-    src/base/base64.cc \
-    src/base/base_switches.cc \
-    src/base/big_endian.cc \
-    src/base/bind_helpers.cc \
-    src/base/callback_helpers.cc \
-    src/base/callback_internal.cc \
-    src/base/command_line.cc \
-    src/base/cpu.cc \
-    src/base/debug/alias.cc \
-    src/base/debug/asan_invalid_access.cc \
-    src/base/debug/crash_logging.cc \
-    src/base/debug/debugger.cc \
-    src/base/debug/debugger_posix.cc \
-    src/base/debug/dump_without_crashing.cc \
-    src/base/debug/proc_maps_linux.cc \
-    src/base/debug/stack_trace.cc \
-    src/base/debug/stack_trace_posix.cc \
-    src/base/environment.cc \
-    src/base/files/file.cc \
-    src/base/files/file_posix.cc \
-    src/base/files/file_enumerator.cc \
-    src/base/files/file_enumerator_posix.cc \
-    src/base/files/file_path.cc \
-    src/base/files/file_path_constants.cc \
-    src/base/files/memory_mapped_file.cc \
-    src/base/files/memory_mapped_file_posix.cc \
-    src/base/files/scoped_file.cc \
-    src/base/files/scoped_temp_dir.cc \
-    src/base/file_util.cc \
-    src/base/file_util_linux.cc \
-    src/base/file_util_posix.cc \
-    src/base/guid.cc \
-    src/base/guid_posix.cc \
-    src/base/hash.cc \
-    src/base/lazy_instance.cc \
-    src/base/location.cc \
-    src/base/md5.cc \
-    src/base/memory/aligned_memory.cc \
-    src/base/memory/ref_counted.cc \
-    src/base/memory/ref_counted_memory.cc \
-    src/base/memory/shared_memory_posix.cc \
-    src/base/memory/singleton.cc \
-    src/base/memory/weak_ptr.cc \
-    src/base/nix/mime_util_xdg.cc \
-    src/base/nix/xdg_util.cc \
-    src/base/path_service.cc \
-    src/base/posix/file_descriptor_shuffle.cc \
-    src/base/posix/global_descriptors.cc \
-    src/base/process/internal_linux.cc \
-    src/base/process/kill.cc \
-    src/base/process/kill_posix.cc \
-    src/base/process/launch.cc \
-    src/base/process/launch_posix.cc \
-    src/base/process/process_handle_linux.cc \
-    src/base/process/process_handle_posix.cc \
-    src/base/process/process_info_linux.cc \
-    src/base/process/process_iterator.cc \
-    src/base/process/process_iterator_linux.cc \
-    src/base/process/process_linux.cc \
-    src/base/process/process_metrics.cc \
-    src/base/process/process_metrics_linux.cc \
-    src/base/process/process_metrics_posix.cc \
-    src/base/process/process_posix.cc \
-    src/base/rand_util.cc \
-    src/base/rand_util_posix.cc \
-    src/base/fast_rand.cpp \
-    src/base/safe_strerror_posix.cc \
-    src/base/sha1_portable.cc \
-    src/base/strings/latin1_string_conversions.cc \
-    src/base/strings/nullable_string16.cc \
-    src/base/strings/safe_sprintf.cc \
-    src/base/strings/string16.cc \
-    src/base/strings/string_number_conversions.cc \
-    src/base/strings/string_split.cc \
-    src/base/strings/string_piece.cc \
-    src/base/strings/string_util.cc \
-    src/base/strings/string_util_constants.cc \
-    src/base/strings/stringprintf.cc \
-    src/base/strings/sys_string_conversions_posix.cc \
-    src/base/strings/utf_offset_string_conversions.cc \
-    src/base/strings/utf_string_conversion_utils.cc \
-    src/base/strings/utf_string_conversions.cc \
-    src/base/synchronization/cancellation_flag.cc \
-    src/base/synchronization/condition_variable_posix.cc \
-    src/base/synchronization/waitable_event_posix.cc \
-    src/base/sys_info.cc \
-    src/base/sys_info_linux.cc \
-    src/base/sys_info_posix.cc \
-    src/base/threading/non_thread_safe_impl.cc \
-    src/base/threading/platform_thread_linux.cc \
-    src/base/threading/platform_thread_posix.cc \
-    src/base/threading/simple_thread.cc \
-    src/base/threading/thread_checker_impl.cc \
-    src/base/threading/thread_collision_warner.cc \
-    src/base/threading/thread_id_name_manager.cc \
-    src/base/threading/thread_local_posix.cc \
-    src/base/threading/thread_local_storage.cc \
-    src/base/threading/thread_local_storage_posix.cc \
-    src/base/threading/thread_restrictions.cc \
-    src/base/threading/watchdog.cc \
-    src/base/time/clock.cc \
-    src/base/time/default_clock.cc \
-    src/base/time/default_tick_clock.cc \
-    src/base/time/tick_clock.cc \
-    src/base/time/time.cc \
-    src/base/time/time_posix.cc \
-    src/base/version.cc \
-    src/base/logging.cc \
-    src/base/class_name.cpp \
-    src/base/errno.cpp \
-    src/base/find_cstr.cpp \
-    src/base/status.cpp \
-    src/base/string_printf.cpp \
-    src/base/thread_local.cpp \
-    src/base/unix_socket.cpp \
-    src/base/endpoint.cpp \
-    src/base/fd_utility.cpp \
-    src/base/files/temp_file.cpp \
-    src/base/files/file_watcher.cpp \
-    src/base/time.cpp \
-    src/base/zero_copy_stream_as_streambuf.cpp \
-    src/base/crc32c.cc \
-    src/base/containers/case_ignored_flat_map.cpp \
-    src/base/iobuf.cpp
+BUTIL_SOURCES = \
+    src/butil/third_party/dmg_fp/g_fmt.cc \
+    src/butil/third_party/dmg_fp/dtoa_wrapper.cc \
+    src/butil/third_party/dynamic_annotations/dynamic_annotations.c \
+    src/butil/third_party/icu/icu_utf.cc \
+    src/butil/third_party/superfasthash/superfasthash.c \
+    src/butil/third_party/modp_b64/modp_b64.cc \
+    src/butil/third_party/nspr/prtime.cc \
+    src/butil/third_party/symbolize/demangle.cc \
+    src/butil/third_party/symbolize/symbolize.cc \
+    src/butil/third_party/xdg_mime/xdgmime.c \
+    src/butil/third_party/xdg_mime/xdgmimealias.c \
+    src/butil/third_party/xdg_mime/xdgmimecache.c \
+    src/butil/third_party/xdg_mime/xdgmimeglob.c \
+    src/butil/third_party/xdg_mime/xdgmimeicon.c \
+    src/butil/third_party/xdg_mime/xdgmimeint.c \
+    src/butil/third_party/xdg_mime/xdgmimemagic.c \
+    src/butil/third_party/xdg_mime/xdgmimeparent.c \
+    src/butil/third_party/xdg_user_dirs/xdg_user_dir_lookup.cc \
+    src/butil/third_party/snappy/snappy-sinksource.cc \
+    src/butil/third_party/snappy/snappy-stubs-internal.cc \
+    src/butil/third_party/snappy/snappy.cc \
+    src/butil/third_party/murmurhash3/murmurhash3.cpp \
+    src/butil/allocator/type_profiler_control.cc \
+    src/butil/arena.cpp \
+    src/butil/at_exit.cc \
+    src/butil/atomicops_internals_x86_gcc.cc \
+    src/butil/barrier_closure.cc \
+    src/butil/base_paths.cc \
+    src/butil/base_paths_posix.cc \
+    src/butil/base64.cc \
+    src/butil/base_switches.cc \
+    src/butil/big_endian.cc \
+    src/butil/bind_helpers.cc \
+    src/butil/callback_helpers.cc \
+    src/butil/callback_internal.cc \
+    src/butil/command_line.cc \
+    src/butil/cpu.cc \
+    src/butil/debug/alias.cc \
+    src/butil/debug/asan_invalid_access.cc \
+    src/butil/debug/crash_logging.cc \
+    src/butil/debug/debugger.cc \
+    src/butil/debug/debugger_posix.cc \
+    src/butil/debug/dump_without_crashing.cc \
+    src/butil/debug/proc_maps_linux.cc \
+    src/butil/debug/stack_trace.cc \
+    src/butil/debug/stack_trace_posix.cc \
+    src/butil/environment.cc \
+    src/butil/files/file.cc \
+    src/butil/files/file_posix.cc \
+    src/butil/files/file_enumerator.cc \
+    src/butil/files/file_enumerator_posix.cc \
+    src/butil/files/file_path.cc \
+    src/butil/files/file_path_constants.cc \
+    src/butil/files/memory_mapped_file.cc \
+    src/butil/files/memory_mapped_file_posix.cc \
+    src/butil/files/scoped_file.cc \
+    src/butil/files/scoped_temp_dir.cc \
+    src/butil/file_util.cc \
+    src/butil/file_util_linux.cc \
+    src/butil/file_util_posix.cc \
+    src/butil/guid.cc \
+    src/butil/guid_posix.cc \
+    src/butil/hash.cc \
+    src/butil/lazy_instance.cc \
+    src/butil/location.cc \
+    src/butil/md5.cc \
+    src/butil/memory/aligned_memory.cc \
+    src/butil/memory/ref_counted.cc \
+    src/butil/memory/ref_counted_memory.cc \
+    src/butil/memory/shared_memory_posix.cc \
+    src/butil/memory/singleton.cc \
+    src/butil/memory/weak_ptr.cc \
+    src/butil/nix/mime_util_xdg.cc \
+    src/butil/nix/xdg_util.cc \
+    src/butil/path_service.cc \
+    src/butil/posix/file_descriptor_shuffle.cc \
+    src/butil/posix/global_descriptors.cc \
+    src/butil/process/internal_linux.cc \
+    src/butil/process/kill.cc \
+    src/butil/process/kill_posix.cc \
+    src/butil/process/launch.cc \
+    src/butil/process/launch_posix.cc \
+    src/butil/process/process_handle_linux.cc \
+    src/butil/process/process_handle_posix.cc \
+    src/butil/process/process_info_linux.cc \
+    src/butil/process/process_iterator.cc \
+    src/butil/process/process_iterator_linux.cc \
+    src/butil/process/process_linux.cc \
+    src/butil/process/process_metrics.cc \
+    src/butil/process/process_metrics_linux.cc \
+    src/butil/process/process_metrics_posix.cc \
+    src/butil/process/process_posix.cc \
+    src/butil/rand_util.cc \
+    src/butil/rand_util_posix.cc \
+    src/butil/fast_rand.cpp \
+    src/butil/safe_strerror_posix.cc \
+    src/butil/sha1_portable.cc \
+    src/butil/strings/latin1_string_conversions.cc \
+    src/butil/strings/nullable_string16.cc \
+    src/butil/strings/safe_sprintf.cc \
+    src/butil/strings/string16.cc \
+    src/butil/strings/string_number_conversions.cc \
+    src/butil/strings/string_split.cc \
+    src/butil/strings/string_piece.cc \
+    src/butil/strings/string_util.cc \
+    src/butil/strings/string_util_constants.cc \
+    src/butil/strings/stringprintf.cc \
+    src/butil/strings/sys_string_conversions_posix.cc \
+    src/butil/strings/utf_offset_string_conversions.cc \
+    src/butil/strings/utf_string_conversion_utils.cc \
+    src/butil/strings/utf_string_conversions.cc \
+    src/butil/synchronization/cancellation_flag.cc \
+    src/butil/synchronization/condition_variable_posix.cc \
+    src/butil/synchronization/waitable_event_posix.cc \
+    src/butil/sys_info.cc \
+    src/butil/sys_info_linux.cc \
+    src/butil/sys_info_posix.cc \
+    src/butil/threading/non_thread_safe_impl.cc \
+    src/butil/threading/platform_thread_linux.cc \
+    src/butil/threading/platform_thread_posix.cc \
+    src/butil/threading/simple_thread.cc \
+    src/butil/threading/thread_checker_impl.cc \
+    src/butil/threading/thread_collision_warner.cc \
+    src/butil/threading/thread_id_name_manager.cc \
+    src/butil/threading/thread_local_posix.cc \
+    src/butil/threading/thread_local_storage.cc \
+    src/butil/threading/thread_local_storage_posix.cc \
+    src/butil/threading/thread_restrictions.cc \
+    src/butil/threading/watchdog.cc \
+    src/butil/time/clock.cc \
+    src/butil/time/default_clock.cc \
+    src/butil/time/default_tick_clock.cc \
+    src/butil/time/tick_clock.cc \
+    src/butil/time/time.cc \
+    src/butil/time/time_posix.cc \
+    src/butil/version.cc \
+    src/butil/logging.cc \
+    src/butil/class_name.cpp \
+    src/butil/errno.cpp \
+    src/butil/find_cstr.cpp \
+    src/butil/status.cpp \
+    src/butil/string_printf.cpp \
+    src/butil/thread_local.cpp \
+    src/butil/unix_socket.cpp \
+    src/butil/endpoint.cpp \
+    src/butil/fd_utility.cpp \
+    src/butil/files/temp_file.cpp \
+    src/butil/files/file_watcher.cpp \
+    src/butil/time.cpp \
+    src/butil/zero_copy_stream_as_streambuf.cpp \
+    src/butil/crc32c.cc \
+    src/butil/containers/case_ignored_flat_map.cpp \
+    src/butil/iobuf.cpp
 
-BASE_OBJS = $(addsuffix .o, $(basename $(BASE_SOURCES)))
+BUTIL_OBJS = $(addsuffix .o, $(basename $(BUTIL_SOURCES)))
 
 BVAR_DIRS = src/bvar src/bvar/detail
 BVAR_SOURCES = $(foreach d,$(BVAR_DIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS))))
@@ -205,7 +205,7 @@ MCPACK2PB_SOURCES = \
 	src/mcpack2pb/serializer.cpp
 MCPACK2PB_OBJS = src/idl_options.pb.o $(addsuffix .o, $(basename $(MCPACK2PB_SOURCES)))
 
-OBJS=$(BASE_OBJS) $(BVAR_OBJS) $(BTHREAD_OBJS) $(JSON2PB_OBJS) $(MCPACK2PB_OBJS) $(BRPC_OBJS)
+OBJS=$(BUTIL_OBJS) $(BVAR_OBJS) $(BTHREAD_OBJS) $(JSON2PB_OBJS) $(MCPACK2PB_OBJS) $(BRPC_OBJS)
 DEBUG_OBJS = $(OBJS:.o=.dbg.o)
 
 .PHONY:all

example/asynchronous_echo_c++/client.cpp

@@ -15,8 +15,8 @@
 // A client sending requests to server asynchronously every 1 second.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/time.h>
+#include <butil/logging.h>
+#include <butil/time.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"
 

example/asynchronous_echo_c++/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 

example/backup_request_c++/client.cpp

@@ -17,8 +17,8 @@
 // and ends the RPC when any response comes back.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/time.h>
+#include <butil/logging.h>
+#include <butil/time.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"
 

example/backup_request_c++/server.cpp

@@ -15,7 +15,7 @@
 // A server sleeping for even-th requests to trigger backup request of client.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 
@@ -60,7 +60,7 @@ public:
                   << " to " << cntl->local_side() << noflush;
         // Sleep a while for 0th, 2nd, 4th, 6th ... requests to trigger backup request
         // at client-side.
-        bool do_sleep = (_count.fetch_add(1, base::memory_order_relaxed) % 2 == 0);
+        bool do_sleep = (_count.fetch_add(1, butil::memory_order_relaxed) % 2 == 0);
         if (do_sleep) {
             LOG(INFO) << ", sleep " << FLAGS_sleep_ms 
                       << " ms to trigger backup request" << noflush;
@@ -75,7 +75,7 @@ public:
         }
     }
 private:
-    base::atomic<int> _count;
+    butil::atomic<int> _count;
 };
 }  // namespace example
 

example/cancel_c++/client.cpp

@@ -15,8 +15,8 @@
 // A client to send 2 requests to server and accept the first returned response.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/time.h>
+#include <butil/logging.h>
+#include <butil/time.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"
 
@@ -85,7 +85,7 @@ int main(int argc, char* argv[]) {
         CancelRPC done1(id2);
         CancelRPC done2(id1);
         
-        base::Timer tm;
+        butil::Timer tm;
         tm.start();
         // Send 2 async calls and join them. They will cancel each other in
         // their done which is run before the RPC being Join()-ed. Canceling

example/cancel_c++/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 

example/cascade_echo_c++/client.cpp

@@ -16,8 +16,8 @@
 // again according to the field `depth'
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/time.h>
+#include <butil/logging.h>
+#include <butil/time.h>
 #include <bthread/bthread.h>
 #include <brpc/channel.h>
 #include <brpc/server.h>

example/cascade_echo_c++/server.cpp

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/channel.h>
 #include <brpc/server.h>
 #include "echo.pb.h"

example/dynamic_partition_echo_c++/client.cpp

@@ -16,10 +16,10 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
-#include <base/time.h>
-#include <base/macros.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
+#include <butil/time.h>
+#include <butil/macros.h>
 #include <brpc/partition_channel.h>
 #include <deque>
 #include "echo.pb.h"
@@ -105,7 +105,7 @@ public:
         char* endptr = NULL;
         out->index = strtol(tag.c_str(), &endptr, 10);
         if (endptr != tag.data() + pos) {
-            LOG(ERROR) << "Invalid index=" << base::StringPiece(tag.data(), pos);
+            LOG(ERROR) << "Invalid index=" << butil::StringPiece(tag.data(), pos);
             return false;
         }
         out->num_partition_kinds = strtol(tag.c_str() + pos + 1, &endptr, 10);

example/dynamic_partition_echo_c++/server.cpp

@@ -16,11 +16,11 @@
 
 #include <vector>
 #include <gflags/gflags.h>
-#include <base/time.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
-#include <base/string_splitter.h>
-#include <base/rand_util.h>
+#include <butil/time.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
+#include <butil/string_splitter.h>
+#include <butil/rand_util.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 
@@ -58,7 +58,7 @@ public:
             double delay = _sleep_us;
             const double a = FLAGS_exception_ratio * 0.5;
             if (a >= 0.0001) {
-                double x = base::RandDouble();
+                double x = butil::RandDouble();
                 if (x < a) {
                     const double min_sleep_us = FLAGS_min_ratio * _sleep_us;
                     delay = min_sleep_us + (_sleep_us - min_sleep_us) * x / a;
@@ -68,8 +68,8 @@ public:
                 }
             }
             if (FLAGS_spin) {
-                int64_t end_time = base::gettimeofday_us() + (int64_t)delay;
-                while (base::gettimeofday_us() < end_time) {}
+                int64_t end_time = butil::gettimeofday_us() + (int64_t)delay;
+                while (butil::gettimeofday_us() < end_time) {}
             } else {
                 bthread_usleep((int64_t)delay);
             }
@@ -107,7 +107,7 @@ int main(int argc, char* argv[]) {
     options.idle_timeout_sec = FLAGS_idle_timeout_s;
     options.max_concurrency = FLAGS_max_concurrency;
 
-    base::StringSplitter sp(FLAGS_sleep_us.c_str(), ',');
+    butil::StringSplitter sp(FLAGS_sleep_us.c_str(), ',');
     std::vector<int64_t> sleep_list;
     for (; sp; ++sp) {
         sleep_list.push_back(strtoll(sp.field(), NULL, 10));
@@ -125,7 +125,7 @@ int main(int argc, char* argv[]) {
         int64_t sleep_us = sleep_list[(size_t)i < sleep_list.size() ? i : (sleep_list.size() - 1)];
         echo_service_impls[i].set_index(i, sleep_us);
         // will be shown on /version page
-        servers[i].set_version(base::string_printf(
+        servers[i].set_version(butil::string_printf(
                     "example/dynamic_partition_echo_c++[%d]", i));
         if (servers[i].AddService(&echo_service_impls[i], 
                                   brpc::SERVER_DOESNT_OWN_SERVICE) != 0) {

example/echo_c++/Makefile

@@ -27,7 +27,7 @@ clean:
 
 echo_client:$(PROTO_OBJS) $(CLIENT_OBJS)
 	@echo "Linking $@"
-	$(CXX) $(LIBPATHS) -Xlinker "-(" $^ -Wl,-Bstatic $(STATIC_LINKINGS) -Wl,-Bdynamic -Xlinker "-)" $(DYNAMIC_LINKINGS) -o $@
+	@$(CXX) $(LIBPATHS) -Xlinker "-(" $^ -Wl,-Bstatic $(STATIC_LINKINGS) -Wl,-Bdynamic -Xlinker "-)" $(DYNAMIC_LINKINGS) -o $@
 
 echo_server:$(PROTO_OBJS) $(SERVER_OBJS)
 	@echo "Linking $@"

example/echo_c++/client.cpp

@@ -15,8 +15,8 @@
 // A client sending requests to server every 1 second.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/time.h>
+#include <butil/logging.h>
+#include <butil/time.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"
 

example/echo_c++/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 

example/echo_c++_hulu_pbrpc/client.cpp

@@ -15,8 +15,8 @@
 // A client sending requests to server every 1 second.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/time.h>
+#include <butil/logging.h>
+#include <butil/time.h>
 #include <brpc/channel.h>
 #include <brpc/policy/hulu_pbrpc_controller.h>
 #include "echo.pb.h"

example/echo_c++_hulu_pbrpc/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/policy/hulu_pbrpc_controller.h>
 #include "echo.pb.h"

example/echo_c++_sofa_pbrpc/client.cpp

@@ -15,8 +15,8 @@
 // A client sending requests to server every 1 second.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/time.h>
+#include <butil/logging.h>
+#include <butil/time.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"
 

example/echo_c++_sofa_pbrpc/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/policy/hulu_pbrpc_controller.h>
 #include "echo.pb.h"

example/echo_c++_ubrpc_compack/client.cpp

@@ -17,8 +17,8 @@
 
 #include <gflags/gflags.h>
 
-#include <base/logging.h>
-#include <base/time.h>
+#include <butil/logging.h>
+#include <butil/time.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"
 

example/echo_c++_ubrpc_compack/server.cpp

@@ -16,7 +16,7 @@
 // This server can be accessed by the client in public/baidu-rpc-ub/example/echo_c++_compack_ubrpc as well.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/policy/ubrpc2pb_protocol.h>
 #include "echo.pb.h"

example/http_c++/benchmark_http.cpp

@@ -16,7 +16,7 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/channel.h>
 #include <brpc/server.h>
 #include <bvar/bvar.h>

example/http_c++/http_client.cpp

@@ -20,7 +20,7 @@
 //   ./http_client www.baidu.com
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/channel.h>
 
 DEFINE_string(d, "", "POST this data to the http server");

example/http_c++/http_server.cpp

@@ -15,7 +15,7 @@
 // A server to receive HttpRequest and send back HttpResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/restful.h>
 #include "http.pb.h"
@@ -49,7 +49,7 @@ public:
             static_cast<brpc::Controller*>(cntl_base);
         // Fill response.
         cntl->http_response().set_content_type("text/plain");
-        base::IOBufBuilder os;
+        butil::IOBufBuilder os;
         os << "queries:";
         for (brpc::URI::QueryIterator it = cntl->http_request().uri().QueryBegin();
                 it != cntl->http_request().uri().QueryEnd(); ++it) {
@@ -77,7 +77,7 @@ public:
     virtual ~FileServiceImpl() {};
 
     static void* SendLargeFile(void* arg) {
-        base::intrusive_ptr<brpc::ProgressiveAttachment> pa(
+        butil::intrusive_ptr<brpc::ProgressiveAttachment> pa(
                 (brpc::ProgressiveAttachment*)arg);
         if (pa == NULL) {
             LOG(ERROR) << "ProgressiveAttachment is NULL";

example/memcache_c++/client.cpp

@@ -16,8 +16,8 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
 #include <brpc/channel.h>
 #include <brpc/memcache.h>
 
@@ -36,19 +36,19 @@ DEFINE_int32(batch, 1, "Pipelined Operations");
 
 bvar::LatencyRecorder g_latency_recorder("client");
 bvar::Adder<int> g_error_count("client_error_count");
-base::static_atomic<int> g_sender_count = BASE_STATIC_ATOMIC_INIT(0);
+butil::static_atomic<int> g_sender_count = BASE_STATIC_ATOMIC_INIT(0);
 
 static void* sender(void* arg) {
     google::protobuf::RpcChannel* channel = 
         static_cast<google::protobuf::RpcChannel*>(arg);
-    const int base_index = g_sender_count.fetch_add(1, base::memory_order_relaxed);
+    const int base_index = g_sender_count.fetch_add(1, butil::memory_order_relaxed);
 
     std::string value;
     std::vector<std::pair<std::string, std::string> > kvs;
     kvs.resize(FLAGS_batch);
     for (int i = 0; i < FLAGS_batch; ++i) {
-        kvs[i].first = base::string_printf("%s%d", FLAGS_key.c_str(), base_index + i);
-        kvs[i].second = base::string_printf("%s%d", FLAGS_value.c_str(), base_index + i);
+        kvs[i].first = butil::string_printf("%s%d", FLAGS_key.c_str(), base_index + i);
+        kvs[i].second = butil::string_printf("%s%d", FLAGS_value.c_str(), base_index + i);
     }
     brpc::MemcacheRequest request;
     for (int i = 0; i < FLAGS_batch; ++i) {
@@ -120,8 +120,8 @@ int main(int argc, char* argv[]) {
     brpc::MemcacheResponse response;
     brpc::Controller cntl;
     for (int i = 0; i < FLAGS_batch * FLAGS_thread_num; ++i) {
-        if (!request.Set(base::string_printf("%s%d", FLAGS_key.c_str(), i),
-                         base::string_printf("%s%d", FLAGS_value.c_str(), i),
+        if (!request.Set(butil::string_printf("%s%d", FLAGS_key.c_str(), i),
+                         butil::string_printf("%s%d", FLAGS_value.c_str(), i),
                          0xdeadbeef + i, FLAGS_exptime, 0)) {
             LOG(ERROR) << "Fail to SET " << i << "th request";
             return -1;

example/multi_threaded_echo_c++/client.cpp

@@ -16,7 +16,7 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"

example/multi_threaded_echo_c++/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 

example/multi_threaded_echo_fns_c++/client.cpp

@@ -16,10 +16,10 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
-#include <base/time.h>
-#include <base/macros.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
+#include <butil/time.h>
+#include <butil/macros.h>
 #include <brpc/channel.h>
 #include <brpc/server.h>
 #include <deque>
@@ -43,7 +43,7 @@ std::string g_attachment;
 
 bvar::LatencyRecorder g_latency_recorder("client");
 bvar::Adder<int> g_error_count("client_error_count");
-base::static_atomic<int> g_sender_count = BASE_STATIC_ATOMIC_INIT(0);
+butil::static_atomic<int> g_sender_count = BASE_STATIC_ATOMIC_INIT(0);
 
 static void* sender(void* arg) {
     // Normally, you should not call a Channel directly, but instead construct
@@ -58,7 +58,7 @@ static void* sender(void* arg) {
         example::EchoResponse response;
         brpc::Controller cntl;
 
-        const int thread_index = g_sender_count.fetch_add(1, base::memory_order_relaxed);
+        const int thread_index = g_sender_count.fetch_add(1, butil::memory_order_relaxed);
         const int input = ((thread_index & 0xFFF) << 20) | (log_id & 0xFFFFF);
         request.set_value(input);
         cntl.set_log_id(log_id ++);  // set by user

example/multi_threaded_echo_fns_c++/server.cpp

@@ -17,11 +17,11 @@
 #include <fcntl.h>  // O_RDONLY
 #include <vector>
 #include <gflags/gflags.h>
-#include <base/time.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
-#include <base/string_splitter.h>
-#include <base/rand_util.h>
+#include <butil/time.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
+#include <butil/string_splitter.h>
+#include <butil/rand_util.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 
@@ -59,7 +59,7 @@ public:
             double delay = _sleep_us;
             const double a = FLAGS_exception_ratio * 0.5;
             if (a >= 0.0001) {
-                double x = base::RandDouble();
+                double x = butil::RandDouble();
                 if (x < a) {
                     const double min_sleep_us = FLAGS_min_ratio * _sleep_us;
                     delay = min_sleep_us + (_sleep_us - min_sleep_us) * x / a;
@@ -69,8 +69,8 @@ public:
                 }
             }
             if (FLAGS_spin) {
-                int64_t end_time = base::gettimeofday_us() + (int64_t)delay;
-                while (base::gettimeofday_us() < end_time) {}
+                int64_t end_time = butil::gettimeofday_us() + (int64_t)delay;
+                while (butil::gettimeofday_us() < end_time) {}
             } else {
                 bthread_usleep((int64_t)delay);
             }
@@ -106,7 +106,7 @@ int main(int argc, char* argv[]) {
     // We need multiple servers in this example.
     brpc::Server* servers = new brpc::Server[FLAGS_server_num];
 
-    base::StringSplitter sp(FLAGS_sleep_us.c_str(), ',');
+    butil::StringSplitter sp(FLAGS_sleep_us.c_str(), ',');
     std::vector<int64_t> sleep_list;
     for (; sp; ++sp) {
         sleep_list.push_back(strtoll(sp.field(), NULL, 10));
@@ -124,7 +124,7 @@ int main(int argc, char* argv[]) {
     for (int i = 0; i < FLAGS_server_num; ++i) {
         int64_t sleep_us = sleep_list[(size_t)i < sleep_list.size() ? i : (sleep_list.size() - 1)];
         echo_service_impls[i].set_index(i, sleep_us);
-        servers[i].set_version(base::string_printf(
+        servers[i].set_version(butil::string_printf(
                     "example/multi_threaded_echo_fns_c++[%d]", i));
         if (servers[i].AddService(&echo_service_impls[i], 
                                   brpc::SERVER_DOESNT_OWN_SERVICE) != 0) {
@@ -148,7 +148,7 @@ int main(int argc, char* argv[]) {
             return -1;
         }
         char buf[64];
-        int nw = snprintf(buf, sizeof(buf), "%s:%d\n", base::my_ip_cstr(), port);
+        int nw = snprintf(buf, sizeof(buf), "%s:%d\n", butil::my_ip_cstr(), port);
         if (write(fd, buf, nw) != nw) {
             LOG(ERROR) << "Fail to fully write int fd=" << fd;
         }

example/multi_threaded_mcpack_c++/client.cpp

@@ -16,7 +16,7 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"

example/multi_threaded_mcpack_c++/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/policy/nshead_mcpack_protocol.h>
 #include "echo.pb.h"

example/nshead_extension_c++/client.cpp

@@ -16,9 +16,9 @@
 
 #include <gflags/gflags.h>
 
-#include <base/logging.h>
-#include <base/time.h>
-#include <base/strings/string_piece.h>
+#include <butil/logging.h>
+#include <butil/time.h>
+#include <butil/strings/string_piece.h>
 #include <brpc/channel.h>
 #include <brpc/nshead_message.h>
 #include <bvar/bvar.h>

example/nshead_extension_c++/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/nshead_service.h>
 

example/nshead_pb_extension_c++/client.cpp

@@ -16,9 +16,9 @@
 
 #include <gflags/gflags.h>
 
-#include <base/logging.h>
-#include <base/time.h>
-#include <base/strings/string_piece.h>
+#include <butil/logging.h>
+#include <butil/time.h>
+#include <butil/strings/string_piece.h>
 #include <brpc/channel.h>
 #include <brpc/nshead_message.h>
 #include <bvar/bvar.h>

example/nshead_pb_extension_c++/server.cpp

@@ -16,7 +16,7 @@
 
 #include <google/protobuf/descriptor.h>
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include <brpc/nshead_pb_service_adaptor.h>
 #include "echo.pb.h"

example/parallel_echo_c++/client.cpp

@@ -16,10 +16,10 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
-#include <base/time.h>
-#include <base/macros.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
+#include <butil/time.h>
+#include <butil/macros.h>
 #include <brpc/parallel_channel.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
@@ -148,7 +148,7 @@ int main(int argc, char* argv[]) {
     g_sub_channel_latency = new bvar::LatencyRecorder[FLAGS_channel_num];
     for (int i = 0; i < FLAGS_channel_num; ++i) {
         std::string name;
-        base::string_printf(&name, "client_sub_%d", i);
+        butil::string_printf(&name, "client_sub_%d", i);
         g_sub_channel_latency[i].expose(name);
     }
 

example/parallel_echo_c++/server.cpp

@@ -15,8 +15,8 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 

example/partition_echo_c++/client.cpp

@@ -16,10 +16,10 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
-#include <base/time.h>
-#include <base/macros.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
+#include <butil/time.h>
+#include <butil/macros.h>
 #include <brpc/partition_channel.h>
 #include <deque>
 #include "echo.pb.h"
@@ -106,7 +106,7 @@ public:
         char* endptr = NULL;
         out->index = strtol(tag.c_str(), &endptr, 10);
         if (endptr != tag.data() + pos) {
-            LOG(ERROR) << "Invalid index=" << base::StringPiece(tag.data(), pos);
+            LOG(ERROR) << "Invalid index=" << butil::StringPiece(tag.data(), pos);
             return false;
         }
         out->num_partition_kinds = strtol(tag.c_str() + pos + 1, &endptr, 10);

example/partition_echo_c++/server.cpp

@@ -15,8 +15,8 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 

example/redis_c++/redis_cli.cpp

@@ -19,7 +19,7 @@
 #include <readline/readline.h>
 #include <readline/history.h>
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/channel.h>
 #include <brpc/redis.h>
 

example/redis_c++/redis_press.cpp

@@ -16,8 +16,8 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
-#include <base/string_printf.h>
+#include <butil/logging.h>
+#include <butil/string_printf.h>
 #include <bvar/bvar.h>
 #include <brpc/channel.h>
 #include <brpc/server.h>
@@ -51,9 +51,9 @@ static void* sender(void* void_args) {
     std::vector<std::pair<std::string, std::string> > kvs;
     kvs.resize(FLAGS_batch);
     for (int i = 0; i < FLAGS_batch; ++i) {
-        kvs[i].first = base::string_printf(
+        kvs[i].first = butil::string_printf(
             "%s_%04d", FLAGS_key.c_str(), args->base_index + i);
-        kvs[i].second = base::string_printf(
+        kvs[i].second = butil::string_printf(
             "%s_%04d", FLAGS_value.c_str(), args->base_index + i);
     }
 

example/selective_echo_c++/client.cpp

@@ -16,7 +16,7 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/selective_channel.h>
 #include <brpc/parallel_channel.h>
 #include "echo.pb.h"
@@ -103,7 +103,7 @@ int main(int argc, char* argv[]) {
     
     // Add an ordinary channel.
     brpc::Channel* sub_channel1 = new brpc::Channel;
-    base::EndPoint pt;
+    butil::EndPoint pt;
     if (str2endpoint(FLAGS_starting_server.c_str(), &pt) != 0 &&
         hostname2endpoint(FLAGS_starting_server.c_str(), &pt) != 0) {
         LOG(ERROR) << "Invalid address=`" << FLAGS_starting_server << "'";
@@ -115,7 +115,7 @@ int main(int argc, char* argv[]) {
     std::ostringstream os;
     os << "list://";
     for (int i = 0; i < 3; ++i) {
-        os << base::EndPoint(pt.ip, pt.port++) << ",";
+        os << butil::EndPoint(pt.ip, pt.port++) << ",";
     }
     if (sub_channel1->Init(os.str().c_str(), FLAGS_load_balancer.c_str(),
                            &options) != 0) {
@@ -137,7 +137,7 @@ int main(int argc, char* argv[]) {
         options.protocol = FLAGS_protocol;
         options.connection_type = FLAGS_connection_type;
         brpc::Channel* c = new brpc::Channel;
-        if (c->Init(base::EndPoint(pt.ip, pt.port++), &options) != 0) {
+        if (c->Init(butil::EndPoint(pt.ip, pt.port++), &options) != 0) {
             LOG(ERROR) << "Fail to init sub channel[" << i << "] of pchan";
             return -1;
         }
@@ -160,7 +160,7 @@ int main(int argc, char* argv[]) {
             os.str("");
             os << "list://";
             for (int j = 0; j < 3; ++j) {
-                os << base::EndPoint(pt.ip, pt.port++) << ",";
+                os << butil::EndPoint(pt.ip, pt.port++) << ",";
             }
             if (c->Init(os.str().c_str(), FLAGS_load_balancer.c_str(),
                         &options) != 0) {
@@ -168,7 +168,7 @@ int main(int argc, char* argv[]) {
                 return -1;
             }
         } else {
-            if (c->Init(base::EndPoint(pt.ip, pt.port++), &options) != 0) {
+            if (c->Init(butil::EndPoint(pt.ip, pt.port++), &options) != 0) {
                 LOG(ERROR) << "Fail to init sub channel[" << i << "] of schan";
                 return -1;
             }

example/selective_echo_c++/server.cpp

@@ -16,10 +16,10 @@
 
 #include <vector>
 #include <gflags/gflags.h>
-#include <base/time.h>
-#include <base/logging.h>
-#include <base/string_splitter.h>
-#include <base/rand_util.h>
+#include <butil/time.h>
+#include <butil/logging.h>
+#include <butil/string_splitter.h>
+#include <butil/rand_util.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 
@@ -57,7 +57,7 @@ public:
             double delay = _sleep_us;
             const double a = FLAGS_exception_ratio * 0.5;
             if (a >= 0.0001) {
-                double x = base::RandDouble();
+                double x = butil::RandDouble();
                 if (x < a) {
                     const double min_sleep_us = FLAGS_min_ratio * _sleep_us;
                     delay = min_sleep_us + (_sleep_us - min_sleep_us) * x / a;
@@ -67,8 +67,8 @@ public:
                 }
             }
             if (FLAGS_spin) {
-                int64_t end_time = base::gettimeofday_us() + (int64_t)delay;
-                while (base::gettimeofday_us() < end_time) {}
+                int64_t end_time = butil::gettimeofday_us() + (int64_t)delay;
+                while (butil::gettimeofday_us() < end_time) {}
             } else {
                 bthread_usleep((int64_t)delay);
             }
@@ -106,7 +106,7 @@ int main(int argc, char* argv[]) {
     options.idle_timeout_sec = FLAGS_idle_timeout_s;
     options.max_concurrency = FLAGS_max_concurrency;
 
-    base::StringSplitter sp(FLAGS_sleep_us.c_str(), ',');
+    butil::StringSplitter sp(FLAGS_sleep_us.c_str(), ',');
     std::vector<int64_t> sleep_list;
     for (; sp; ++sp) {
         sleep_list.push_back(strtoll(sp.field(), NULL, 10));
@@ -124,7 +124,7 @@ int main(int argc, char* argv[]) {
         int64_t sleep_us = sleep_list[(size_t)i < sleep_list.size() ? i : (sleep_list.size() - 1)];
         echo_service_impls[i].set_index(i, sleep_us);
         // will be shown on /version page
-        servers[i].set_version(base::string_printf(
+        servers[i].set_version(butil::string_printf(
                     "example/selective_echo_c++[%d]", i));
         if (servers[i].AddService(&echo_service_impls[i], 
                                   brpc::SERVER_DOESNT_OWN_SERVICE) != 0) {

example/session_data_and_thread_local/client.cpp

@@ -16,7 +16,7 @@
 
 #include <gflags/gflags.h>
 #include <bthread/bthread.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/channel.h>
 #include "echo.pb.h"
 #include <bvar/bvar.h>
@@ -61,9 +61,9 @@ static void* sender(void* arg) {
 
         // Because `done'(last parameter) is NULL, this function waits until
         // the response comes back or error occurs(including timedout).
-        const int64_t start_time = base::cpuwide_time_us();
+        const int64_t start_time = butil::cpuwide_time_us();
         stub.Echo(&cntl, &request, &response, NULL);
-        const int64_t end_time = base::cpuwide_time_us();
+        const int64_t end_time = butil::cpuwide_time_us();
         const int64_t elp = end_time - start_time;
         if (!cntl.Failed()) {
             g_latency_recorder << elp;

example/session_data_and_thread_local/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse asynchronously.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 
@@ -27,13 +27,13 @@ DEFINE_int32(logoff_ms, 2000, "Maximum duration of server's LOGOFF state "
              "(waiting for client to close connection before server stops)");
 DEFINE_int32(max_concurrency, 0, "Limit of request processing in parallel");
 
-base::atomic<int> nsd(0);
+butil::atomic<int> nsd(0);
 struct MySessionLocalData {
     MySessionLocalData() : x(123) {
-        nsd.fetch_add(1, base::memory_order_relaxed);
+        nsd.fetch_add(1, butil::memory_order_relaxed);
     }
     ~MySessionLocalData() {
-        nsd.fetch_sub(1, base::memory_order_relaxed);
+        nsd.fetch_sub(1, butil::memory_order_relaxed);
     }
 
     int x;
@@ -50,13 +50,13 @@ public:
     }
 };
 
-base::atomic<int> ntls(0);
+butil::atomic<int> ntls(0);
 struct MyThreadLocalData {
     MyThreadLocalData() : y(0) {
-        ntls.fetch_add(1, base::memory_order_relaxed);
+        ntls.fetch_add(1, butil::memory_order_relaxed);
     }
     ~MyThreadLocalData() {
-        ntls.fetch_sub(1, base::memory_order_relaxed);
+        ntls.fetch_sub(1, butil::memory_order_relaxed);
     }
     static void deleter(void* d) {
         delete static_cast<MyThreadLocalData*>(d);
@@ -180,8 +180,8 @@ public:
         // We don't want to call done->Run() here, release the guard.
         done_guard.release();
         
-        LOG_EVERY_SECOND(INFO) << "ntls=" << ntls.load(base::memory_order_relaxed)
-                               << " nsd=" << nsd.load(base::memory_order_relaxed);
+        LOG_EVERY_SECOND(INFO) << "ntls=" << ntls.load(butil::memory_order_relaxed)
+                               << " nsd=" << nsd.load(butil::memory_order_relaxed);
     }
 
 private:

example/streaming_echo_c++/client.cpp

@@ -15,7 +15,7 @@
 // A client sending requests to server in batch every 1 second.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/channel.h>
 #include <brpc/stream.h>
 #include "echo.pb.h"
@@ -65,10 +65,10 @@ int main(int argc, char* argv[]) {
     }
     
     while (!brpc::IsAskedToQuit()) {
-        base::IOBuf msg1;
+        butil::IOBuf msg1;
         msg1.append("abcdefghijklmnopqrstuvwxyz");
         CHECK_EQ(0, brpc::StreamWrite(stream, msg1));
-        base::IOBuf msg2;
+        butil::IOBuf msg2;
         msg2.append("0123456789");
         CHECK_EQ(0, brpc::StreamWrite(stream, msg2));
         sleep(1);

example/streaming_echo_c++/server.cpp

@@ -15,7 +15,7 @@
 // A server to receive EchoRequest and send back EchoResponse.
 
 #include <gflags/gflags.h>
-#include <base/logging.h>
+#include <butil/logging.h>
 #include <brpc/server.h>
 #include "echo.pb.h"
 #include <brpc/stream.h>
@@ -30,7 +30,7 @@ DEFINE_int32(logoff_ms, 2000, "Maximum duration of server's LOGOFF state "
 class StreamReceiver : public brpc::StreamInputHandler {
 public:
     virtual int on_received_messages(brpc::StreamId id, 
-                                     base::IOBuf *const messages[], 
+                                     butil::IOBuf *const messages[], 
                                      size_t size) {
         LOG(INFO) << "Received from Stream=" << id << ": " << noflush;
         for (size_t i = 0; i < size; ++i) {

src/base/barrier_closure.cc

@@ -1,52 +0,0 @@
-// Copyright 2013 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.
-
-#include "base/barrier_closure.h"
-
-#include "base/atomic_ref_count.h"
-#include "base/bind.h"
-
-namespace {
-
-// Maintains state for a BarrierClosure.
-class BarrierInfo {
- public:
-  BarrierInfo(int num_callbacks_left, const base::Closure& done_closure);
-  void Run();
-
- private:
-  base::AtomicRefCount num_callbacks_left_;
-  base::Closure done_closure_;
-};
-
-BarrierInfo::BarrierInfo(int num_callbacks, const base::Closure& done_closure)
-    : num_callbacks_left_(num_callbacks),
-      done_closure_(done_closure) {
-}
-
-void BarrierInfo::Run() {
-  DCHECK(!base::AtomicRefCountIsZero(&num_callbacks_left_));
-  if (!base::AtomicRefCountDec(&num_callbacks_left_)) {
-    done_closure_.Run();
-    done_closure_.Reset();
-  }
-}
-
-}  // namespace
-
-namespace base {
-
-base::Closure BarrierClosure(int num_callbacks_left,
-                             const base::Closure& done_closure) {
-  DCHECK(num_callbacks_left >= 0);
-
-  if (num_callbacks_left == 0)
-    done_closure.Run();
-
-  return base::Bind(&BarrierInfo::Run,
-                    base::Owned(
-                        new BarrierInfo(num_callbacks_left, done_closure)));
-}
-
-}  // namespace base

src/brpc/acceptor.cpp

@@ -16,9 +16,9 @@
 //          Ge,Jun(gejun@baidu.com)
 
 #include <gflags/gflags.h>
-#include "base/fd_guard.h"                 // fd_guard 
-#include "base/fd_utility.h"               // make_close_on_exec
-#include "base/time.h"                     // gettimeofday_us
+#include "butil/fd_guard.h"                 // fd_guard 
+#include "butil/fd_utility.h"               // make_close_on_exec
+#include "butil/time.h"                     // gettimeofday_us
 #include "brpc/acceptor.h"
 
 
@@ -158,7 +158,7 @@ int Acceptor::Initialize() {
 
 // NOTE: Join() can happen before StopAccept()
 void Acceptor::Join() {
-    std::unique_lock<base::Mutex> mu(_map_mutex);
+    std::unique_lock<butil::Mutex> mu(_map_mutex);
     if (_status != STOPPING && _status != RUNNING) {  // no need to join.
         return;
     }
@@ -200,7 +200,7 @@ void Acceptor::ListConnections(std::vector<SocketId>* conn_list,
     // ConnectionCount is inaccurate, enough space is reserved
     conn_list->reserve(ConnectionCount() + 10);
 
-    std::unique_lock<base::Mutex> mu(_map_mutex);
+    std::unique_lock<butil::Mutex> mu(_map_mutex);
     if (!_socket_map.initialized()) {
         // Optional. Uninitialized FlatMap should be iteratable.
         return;
@@ -240,7 +240,7 @@ void Acceptor::OnNewConnectionsUntilEAGAIN(Socket* acception) {
     while (1) {
         struct sockaddr in_addr;
         socklen_t in_len = sizeof(in_addr);
-        base::fd_guard in_fd(accept(acception->fd(), &in_addr, &in_len));
+        butil::fd_guard in_fd(accept(acception->fd(), &in_addr, &in_len));
         if (in_fd < 0) {
             // no EINTR because listened fd is non-blocking.
             if (errno == EAGAIN) {
@@ -267,7 +267,7 @@ void Acceptor::OnNewConnectionsUntilEAGAIN(Socket* acception) {
         SocketOptions options;
         options.keytable_pool = am->_keytable_pool;
         options.fd = in_fd;
-        options.remote_side = base::EndPoint(*(sockaddr_in*)&in_addr);
+        options.remote_side = butil::EndPoint(*(sockaddr_in*)&in_addr);
         options.user = acception->user();
         options.on_edge_triggered_events = InputMessenger::OnNewMessages;
         options.ssl_ctx = am->_ssl_ctx;

src/brpc/acceptor.h

@@ -18,8 +18,8 @@
 #ifndef BRPC_ACCEPTOR_H
 #define BRPC_ACCEPTOR_H
 
-#include "base/synchronization/condition_variable.h"
-#include "base/containers/flat_map.h"
+#include "butil/synchronization/condition_variable.h"
+#include "butil/containers/flat_map.h"
 #include "brpc/input_messenger.h"
 
 
@@ -32,7 +32,7 @@ struct ConnectStatistics {
 // process messages from which it reads
 class Acceptor : public InputMessenger {
 public:
-    typedef base::FlatMap<SocketId, ConnectStatistics> SocketMap;
+    typedef butil::FlatMap<SocketId, ConnectStatistics> SocketMap;
 
     enum Status {
         UNINITIALIZED = 0,
@@ -97,8 +97,8 @@ private:
     // The Socket tso accept connections.
     SocketId _acception_id;
 
-    base::Mutex _map_mutex;
-    base::ConditionVariable _empty_cond;
+    butil::Mutex _map_mutex;
+    butil::ConditionVariable _empty_cond;
     
     // The map containing all the accepted sockets
     SocketMap _socket_map;

src/brpc/adaptive_connection_type.cpp

@@ -14,21 +14,21 @@
 
 // Authors: Ge,Jun (gejun@baidu.com)
 
-#include "base/logging.h"
+#include "butil/logging.h"
 #include "brpc/adaptive_connection_type.h"
 
 
 namespace brpc {
 
 inline bool CompareStringPieceWithoutCase(
-        const base::StringPiece& s1, const char* s2) {
+        const butil::StringPiece& s1, const char* s2) {
     if (strlen(s2) != s1.size()) {
         return false;
     }
     return strncasecmp(s1.data(), s2, s1.size()) == 0;
 }
 
-ConnectionType StringToConnectionType(const base::StringPiece& type,
+ConnectionType StringToConnectionType(const butil::StringPiece& type,
                                       bool print_log_on_unknown) {
     if (CompareStringPieceWithoutCase(type, "single")) {
         return CONNECTION_TYPE_SINGLE;
@@ -57,7 +57,7 @@ const char* ConnectionTypeToString(ConnectionType type) {
     return "unknown";
 }
 
-void AdaptiveConnectionType::operator=(const base::StringPiece& name) {
+void AdaptiveConnectionType::operator=(const butil::StringPiece& name) {
     if (name.empty()) {
         _type = CONNECTION_TYPE_UNKNOWN;
         _error = false;

src/brpc/adaptive_connection_type.h

@@ -20,7 +20,7 @@
 // To brpc developers: This is a header included by user, don't depend
 // on internal structures, use opaque pointers instead.
 
-#include "base/strings/string_piece.h"
+#include "butil/strings/string_piece.h"
 #include "brpc/options.pb.h"
 
 namespace brpc {
@@ -28,9 +28,9 @@ namespace brpc {
 // Convert a case-insensitive string to corresponding ConnectionType
 // Possible options are: short, pooled, single
 // Returns: CONNECTION_TYPE_UNKNOWN on error.
-ConnectionType StringToConnectionType(const base::StringPiece& type,
+ConnectionType StringToConnectionType(const butil::StringPiece& type,
                                       bool print_log_on_unknown);
-inline ConnectionType StringToConnectionType(const base::StringPiece& type)
+inline ConnectionType StringToConnectionType(const butil::StringPiece& type)
 { return StringToConnectionType(type, true); }
 
 // Convert a ConnectionType to a c-style string.
@@ -47,7 +47,7 @@ public:
         _type = type;
         _error = false;
     }
-    void operator=(const base::StringPiece& name);
+    void operator=(const butil::StringPiece& name);
 
     operator ConnectionType() const { return _type; }
     const char* name() const { return ConnectionTypeToString(_type); }

src/brpc/adaptive_protocol_type.h

@@ -18,7 +18,7 @@
 // To brpc developers: This is a header included by user, don't depend
 // on internal structures, use opaque pointers instead.
 
-#include "base/strings/string_piece.h"
+#include "butil/strings/string_piece.h"
 #include "brpc/options.pb.h"
 
 namespace brpc {
@@ -28,9 +28,9 @@ namespace brpc {
 // Convert a case-insensitive string to corresponding ProtocolType which is
 // defined in protocol/brpc/options.proto
 // Returns: PROTOCOL_UNKNOWN on error.
-ProtocolType StringToProtocolType(const base::StringPiece& type,
+ProtocolType StringToProtocolType(const butil::StringPiece& type,
                                   bool print_log_on_unknown);
-inline ProtocolType StringToProtocolType(const base::StringPiece& type)
+inline ProtocolType StringToProtocolType(const butil::StringPiece& type)
 { return StringToProtocolType(type, true); }
 
 // Convert a ProtocolType to a c-style string.
@@ -44,7 +44,7 @@ public:
     ~AdaptiveProtocolType() {}
 
     void operator=(ProtocolType type) { _type = type; }
-    void operator=(const base::StringPiece& name)
+    void operator=(const butil::StringPiece& name)
     { _type = StringToProtocolType(name); };
 
     operator ProtocolType() const { return _type; }

src/brpc/amf.cpp

@@ -15,9 +15,9 @@
 // Authors: Ge,Jun (gejun@baidu.com)
 
 #include <google/protobuf/descriptor.h>
-#include "base/sys_byteorder.h"
-#include "base/logging.h"
-#include "base/find_cstr.h"
+#include "butil/sys_byteorder.h"
+#include "butil/logging.h"
+#include "butil/find_cstr.h"
 #include "brpc/log.h"
 #include "brpc/amf.h"
 
@@ -131,14 +131,14 @@ void AMFField::SlowerClear() {
 
 const AMFField* AMFObject::Find(const char* name) const {
     std::map<std::string, AMFField>::const_iterator it =
-        base::find_cstr(_fields, name);
+        butil::find_cstr(_fields, name);
     if (it != _fields.end()) {
         return &it->second;
     }
     return NULL;
 }
 
-void AMFField::SetString(const base::StringPiece& str) {
+void AMFField::SetString(const butil::StringPiece& str) {
     // TODO: Try to reuse the space.
     Clear();
     if (str.size() < SSO_LIMIT) {
@@ -216,7 +216,7 @@ AMFArray* AMFField::MutableArray() {
 
 // ============= AMFObject =============
 
-void AMFObject::SetString(const std::string& name, const base::StringPiece& str) {
+void AMFObject::SetString(const std::string& name, const butil::StringPiece& str) {
     _fields[name].SetString(str);
 }
 
@@ -939,7 +939,7 @@ void AMFArray::RemoveLastField() {
 
 // [ Write ]
 
-void WriteAMFString(const base::StringPiece& str, AMFOutputStream* stream) {
+void WriteAMFString(const butil::StringPiece& str, AMFOutputStream* stream) {
     if (str.size() < 65536u) {
         stream->put_u8(AMF_MARKER_STRING);
         stream->put_u16(str.size());
@@ -1068,13 +1068,13 @@ static void WriteAMFField(const AMFField& field, AMFOutputStream* stream) {
         break;
     case AMF_MARKER_STRING: {
         stream->put_u8(AMF_MARKER_STRING);
-        const base::StringPiece str = field.AsString();
+        const butil::StringPiece str = field.AsString();
         stream->put_u16(str.size());
         stream->putn(str.data(), str.size());
     } break;
     case AMF_MARKER_LONG_STRING: {
         stream->put_u8(AMF_MARKER_LONG_STRING);
-        const base::StringPiece str = field.AsString();
+        const butil::StringPiece str = field.AsString();
         stream->put_u32(str.size());
         stream->putn(str.data(), str.size());
     } break;

src/brpc/amf.h

@@ -21,7 +21,7 @@
 #include <deque>
 #include <google/protobuf/io/zero_copy_stream.h>
 #include <google/protobuf/message.h>
-#include "base/sys_byteorder.h"
+#include "butil/sys_byteorder.h"
 
 
 namespace brpc {
@@ -163,14 +163,14 @@ public:
     { return _type == AMF_MARKER_OBJECT || _type == AMF_MARKER_ECMA_ARRAY; }
     bool IsArray() const { return _type == AMF_MARKER_STRICT_ARRAY; }
     
-    base::StringPiece AsString() const
-    { return base::StringPiece((_is_shortstr ? _shortstr : _str), _strsize); }
+    butil::StringPiece AsString() const
+    { return butil::StringPiece((_is_shortstr ? _shortstr : _str), _strsize); }
     bool AsBool() const { return _b; }
     double AsNumber() const { return _num; }
     const AMFObject& AsObject() const { return *_obj; }
     const AMFArray& AsArray() const { return *_arr; }
 
-    void SetString(const base::StringPiece& str);
+    void SetString(const butil::StringPiece& str);
     void SetBool(bool val);
     void SetNumber(double val);
     void SetNull();
@@ -206,7 +206,7 @@ public:
     void Remove(const std::string& name) { _fields.erase(name); }
     void Clear() { _fields.clear(); }
     
-    void SetString(const std::string& name, const base::StringPiece& val);
+    void SetString(const std::string& name, const butil::StringPiece& val);
     void SetBool(const std::string& name, bool val);
     void SetNumber(const std::string& name, double val);
     void SetNull(const std::string& name);
@@ -238,7 +238,7 @@ public:
     AMFField& operator[](size_t index);
     size_t size() const { return _size; }
 
-    void AddString(const base::StringPiece& val) { AddField()->SetString(val); }
+    void AddString(const butil::StringPiece& val) { AddField()->SetString(val); }
     void AddBool(bool val) { AddField()->SetBool(val); }
     void AddNumber(double val) { AddField()->SetNumber(val); }
     void AddNull() { AddField()->SetNull(); }
@@ -281,7 +281,7 @@ bool ReadAMFArray(AMFArray* arr, AMFInputStream* stream);
 
 // Serialize types into the stream.
 // Check stream->good() for successfulness after one or multiple WriteAMFxxx.
-void WriteAMFString(const base::StringPiece& val, AMFOutputStream* stream);
+void WriteAMFString(const butil::StringPiece& val, AMFOutputStream* stream);
 void WriteAMFBool(bool val, AMFOutputStream* stream);
 void WriteAMFNumber(double val, AMFOutputStream* stream);
 void WriteAMFUint32(uint32_t val, AMFOutputStream* stream);

src/brpc/amf_inl.h

@@ -62,7 +62,7 @@ inline size_t AMFInputStream::cut_u8(uint8_t* val) {
 inline size_t AMFInputStream::cut_u16(uint16_t* val) {
     if (_size >= 2) {
         const uint16_t netval = *(uint16_t*)_data;
-        *val = base::NetToHost16(netval);
+        *val = butil::NetToHost16(netval);
         _data = (const char*)_data + 2;
         _size -= 2;
         _popped_bytes += 2;
@@ -70,14 +70,14 @@ inline size_t AMFInputStream::cut_u16(uint16_t* val) {
     }
     uint16_t netval = 0;
     const size_t ret = cutn(&netval, 2);
-    *val = base::NetToHost16(netval);
+    *val = butil::NetToHost16(netval);
     return ret;
 }
 
 inline size_t AMFInputStream::cut_u32(uint32_t* val) {
     if (_size >= 4) {
         const uint32_t netval = *(uint32_t*)_data;
-        *val = base::NetToHost32(netval);
+        *val = butil::NetToHost32(netval);
         _data = (const char*)_data + 4;
         _size -= 4;
         _popped_bytes += 4;
@@ -85,14 +85,14 @@ inline size_t AMFInputStream::cut_u32(uint32_t* val) {
     }
     uint32_t netval = 0;
     const size_t ret = cutn(&netval, 4);
-    *val = base::NetToHost32(netval);
+    *val = butil::NetToHost32(netval);
     return ret;
 }
 
 inline size_t AMFInputStream::cut_u64(uint64_t* val) {
     if (_size >= 8) {
         const uint64_t netval = *(uint64_t*)_data;
-        *val = base::NetToHost64(netval);
+        *val = butil::NetToHost64(netval);
         _data = (const char*)_data + 8;
         _size -= 8;
         _popped_bytes += 8;
@@ -100,7 +100,7 @@ inline size_t AMFInputStream::cut_u64(uint64_t* val) {
     }
     uint64_t netval = 0;
     const size_t ret = cutn(&netval, 8);
-    *val = base::NetToHost64(netval);
+    *val = butil::NetToHost64(netval);
     return ret;
 }
 
@@ -149,17 +149,17 @@ inline void AMFOutputStream::put_u8(uint8_t val) {
 }
 
 inline void AMFOutputStream::put_u16(uint16_t val) {
-    uint16_t netval = base::HostToNet16(val);
+    uint16_t netval = butil::HostToNet16(val);
     return putn(&netval, sizeof(netval));
 }
 
 inline void AMFOutputStream::put_u32(uint32_t val) {
-    uint32_t netval = base::HostToNet32(val);
+    uint32_t netval = butil::HostToNet32(val);
     return putn(&netval, sizeof(netval));
 }
 
 inline void AMFOutputStream::put_u64(uint64_t val) {
-    uint64_t netval = base::HostToNet64(val);
+    uint64_t netval = butil::HostToNet64(val);
     return putn(&netval, sizeof(netval));
 }
 

src/brpc/authenticator.h

@@ -18,8 +18,8 @@
 #define BRPC_AUTHENTICATOR_H
 
 #include <ostream>
-#include "base/endpoint.h"                    // base::EndPoint
-#include "base/macros.h"                      // BAIDU_CONCAT
+#include "butil/endpoint.h"                    // butil::EndPoint
+#include "butil/macros.h"                      // BAIDU_CONCAT
 #include "brpc/extension.h"              // Extension<T>
 
 
@@ -69,7 +69,7 @@ public:
     // pointer from `Controller'.
     // Returns 0 on success, error code otherwise
     virtual int VerifyCredential(const std::string& auth_str,
-                                 const base::EndPoint& client_addr,
+                                 const butil::EndPoint& client_addr,
                                  AuthContext* out_ctx) const = 0;
 
 };

src/brpc/builtin/bthreads_service.cpp

@@ -34,7 +34,7 @@ void BthreadsService::default_method(::google::protobuf::RpcController* cntl_bas
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);
     cntl->http_response().set_content_type("text/plain");
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     const std::string& constraint = cntl->http_request().unresolved_path();
     
     if (constraint.empty()) {

src/brpc/builtin/common.cpp

@@ -18,10 +18,10 @@
 #include <sys/time.h>
 #include <fcntl.h>                          // O_RDONLY
 #include <gflags/gflags.h>
-#include "base/logging.h"
-#include "base/fd_guard.h"                  // fd_guard
-#include "base/file_util.h"                 // base::FilePath
-#include "base/third_party/murmurhash3/murmurhash3.h"
+#include "butil/logging.h"
+#include "butil/fd_guard.h"                  // fd_guard
+#include "butil/file_util.h"                 // butil::FilePath
+#include "butil/third_party/murmurhash3/murmurhash3.h"
 #include "brpc/server.h"
 #include "brpc/builtin/common.h"
 
@@ -140,7 +140,7 @@ std::ostream& operator<<(std::ostream& os, const Path& link) {
     return os;
 }
 
-const base::EndPoint *Path::LOCAL = (base::EndPoint *)0x01;
+const butil::EndPoint *Path::LOCAL = (butil::EndPoint *)0x01;
 
 void AppendFileName(std::string* dir, const std::string& filename) {
     if (dir->empty()) {
@@ -149,20 +149,20 @@ void AppendFileName(std::string* dir, const std::string& filename) {
     }
     const size_t len = filename.size();
     if (len >= 3) {
-        if (base::back_char(*dir) != '/') {
+        if (butil::back_char(*dir) != '/') {
             dir->push_back('/');
         }
         dir->append(filename);
     } else if (len == 1) {
         if (filename[0] != '.') {
-            if (base::back_char(*dir) != '/') {
+            if (butil::back_char(*dir) != '/') {
                 dir->push_back('/');
             }
             dir->append(filename);
         }
     } else if (len == 2) {
         if (filename[0] != '.' || filename[1] != '.') {
-            if (base::back_char(*dir) != '/') {
+            if (butil::back_char(*dir) != '/') {
                 dir->push_back('/');
             }
             dir->append(filename);
@@ -311,7 +311,7 @@ const char* ProfilingType2String(ProfilingType t) {
 }
 
 ssize_t ReadCommandLine(char* buf, size_t len, bool with_args) {
-    base::fd_guard fd(open("/proc/self/cmdline", O_RDONLY));
+    butil::fd_guard fd(open("/proc/self/cmdline", O_RDONLY));
     if (fd < 0) {
         LOG(ERROR) << "Fail to open /proc/self/cmdline";
         return -1;
@@ -347,19 +347,19 @@ ssize_t ReadCommandLine(char* buf, size_t len, bool with_args) {
 }
 
 int FileChecksum(const char* file_path, unsigned char* checksum) {
-    base::fd_guard fd(open(file_path, O_RDONLY));
+    butil::fd_guard fd(open(file_path, O_RDONLY));
     if (fd < 0) {
         PLOG(ERROR) << "Fail to open `" << file_path << "'";
         return -1;
     }
     char block[16*1024];   // 16k each time
     ssize_t size = 0L;
-    base::MurmurHash3_x64_128_Context mm_ctx;
-    base::MurmurHash3_x64_128_Init(&mm_ctx, 0);
+    butil::MurmurHash3_x64_128_Context mm_ctx;
+    butil::MurmurHash3_x64_128_Init(&mm_ctx, 0);
     while ((size = read(fd, block, sizeof(block))) > 0) {
-        base::MurmurHash3_x64_128_Update(&mm_ctx, block, size);
+        butil::MurmurHash3_x64_128_Update(&mm_ctx, block, size);
     }
-    base::MurmurHash3_x64_128_Final(checksum, &mm_ctx);
+    butil::MurmurHash3_x64_128_Final(checksum, &mm_ctx);
     return 0;
 }
 

src/brpc/builtin/common.h

@@ -19,7 +19,7 @@
 
 #include <vector>                           // std::vector
 #include <gflags/gflags_declare.h>
-#include "base/endpoint.h"
+#include "butil/endpoint.h"
 #include "brpc/http_header.h"
 
 
@@ -68,15 +68,15 @@ struct PrintedAsDateTime {
 std::ostream& operator<<(std::ostream& os, const PrintedAsDateTime&);
 
 struct Path {
-    static const base::EndPoint *LOCAL;
-    Path(const char* uri2, const base::EndPoint* html_addr2)
+    static const butil::EndPoint *LOCAL;
+    Path(const char* uri2, const butil::EndPoint* html_addr2)
         : uri(uri2), html_addr(html_addr2), text(NULL) {}
     
-    Path(const char* uri2, const base::EndPoint* html_addr2, const char* text2)
+    Path(const char* uri2, const butil::EndPoint* html_addr2, const char* text2)
         : uri(uri2), html_addr(html_addr2), text(text2) {}
 
     const char* uri;
-    const base::EndPoint* html_addr;
+    const butil::EndPoint* html_addr;
     const char* text;
 };
 std::ostream& operator<<(std::ostream& os, const Path& link);

src/brpc/builtin/connections_service.cpp

@@ -52,14 +52,14 @@ inline const char* SSLStateToYesNo(SSLState s, bool use_html) {
 }
 
 struct NameOfPoint {
-    explicit NameOfPoint(const base::EndPoint& pt_) : pt(pt_) {}
-    base::EndPoint pt;
+    explicit NameOfPoint(const butil::EndPoint& pt_) : pt(pt_) {}
+    butil::EndPoint pt;
 };
 
 std::ostream& operator<<(std::ostream& os, const NameOfPoint& nop) {
     char buf[128];
     if (FLAGS_show_hostname_instead_of_ip &&
-        base::endpoint2hostname(nop.pt, buf, sizeof(buf)) == 0) {
+        butil::endpoint2hostname(nop.pt, buf, sizeof(buf)) == 0) {
         return os << buf;
     } else {
         return os << nop.pt;
@@ -207,7 +207,7 @@ void ConnectionsService::PrintConnections(
                 if (pref_index == (int)PROTOCOL_NSHEAD &&
                     server->options().nshead_service != NULL) {
                     if (nshead_service_name.empty()) {
-                        nshead_service_name = BriefName(base::class_name_str(
+                        nshead_service_name = BriefName(butil::class_name_str(
                                 *server->options().nshead_service));
                     }
                     pref_prot = nshead_service_name.c_str();
@@ -287,7 +287,7 @@ void ConnectionsService::default_method(
     const Server* server = cntl->server();
     Acceptor* am = server->_am;
     Acceptor* internal_am = server->_internal_am;
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     const bool use_html = UseHTML(cntl->http_request());
     cntl->http_response().set_content_type(
         use_html ? "text/html" : "text/plain");

src/brpc/builtin/dir_service.cpp

@@ -17,8 +17,8 @@
 #include <ostream>
 #include <dirent.h>                    // opendir
 #include <fcntl.h>                     // O_RDONLY
-#include "base/fd_guard.h"
-#include "base/fd_utility.h"
+#include "butil/fd_guard.h"
+#include "butil/fd_utility.h"
 
 #include "brpc/closure_guard.h"        // ClosureGuard
 #include "brpc/controller.h"           // Controller
@@ -47,15 +47,15 @@ void DirService::default_method(::google::protobuf::RpcController* cntl_base,
     }
     DIR* dir = opendir(open_path.c_str());
     if (NULL == dir) {
-        base::fd_guard fd(open(open_path.c_str(), O_RDONLY));
+        butil::fd_guard fd(open(open_path.c_str(), O_RDONLY));
         if (fd < 0) {
             cntl->SetFailed(errno, "Cannot open `%s'", open_path.c_str());
             return;
         }
-        base::make_non_blocking(fd);
-        base::make_close_on_exec(fd);
+        butil::make_non_blocking(fd);
+        butil::make_close_on_exec(fd);
 
-        base::IOPortal read_portal;
+        butil::IOPortal read_portal;
         size_t total_read = 0;
         do {
             const ssize_t nr = read_portal.append_from_file_descriptor(
@@ -69,7 +69,7 @@ void DirService::default_method(::google::protobuf::RpcController* cntl_base,
             }
             total_read += nr;
         } while (total_read < MAX_READ);
-        base::IOBuf& resp = cntl->response_attachment();
+        butil::IOBuf& resp = cntl->response_attachment();
         resp.swap(read_portal);
         if (total_read >= MAX_READ) {
             std::ostringstream oss;
@@ -79,7 +79,7 @@ void DirService::default_method(::google::protobuf::RpcController* cntl_base,
         cntl->http_response().set_content_type("text/plain");
     } else {
         const bool use_html = UseHTML(cntl->http_request());
-        const base::EndPoint* const html_addr = (use_html ? Path::LOCAL : NULL);
+        const butil::EndPoint* const html_addr = (use_html ? Path::LOCAL : NULL);
         cntl->http_response().set_content_type(
             use_html ? "text/html" : "text/plain");
 
@@ -98,7 +98,7 @@ void DirService::default_method(::google::protobuf::RpcController* cntl_base,
         CHECK_EQ(0, closedir(dir));
         
         std::sort(files.begin(), files.end());
-        base::IOBufBuilder os;
+        butil::IOBufBuilder os;
         if (use_html) {
             os << "<!DOCTYPE html><html><body><pre>";
         }

src/brpc/builtin/flags_service.cpp

@@ -19,8 +19,8 @@
 #include <set>
 #include <gflags/gflags.h>                  // google::GetAllFlags 
                                             // google::CommandLineFlagInfo
-#include "base/string_printf.h"
-#include "base/string_splitter.h"
+#include "butil/string_printf.h"
+#include "butil/string_splitter.h"
 
 #include "brpc/closure_guard.h"        // ClosureGuard
 #include "brpc/controller.h"           // Controller
@@ -111,7 +111,7 @@ void FlagsService::set_value_page(Controller* cntl,
         cntl->SetFailed(ENOMETHOD, "No such gflag");
         return;
     }
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     const bool is_string = (info.type == "string");
     os << "<!DOCTYPE html><html><body>"
         "<form action='' method='get'>"
@@ -174,7 +174,7 @@ void FlagsService::default_method(::google::protobuf::RpcController* cntl_base,
                             (value_str->empty() ? "empty string" : value_str->c_str()));
             return;
         }
-        base::IOBufBuilder os;
+        butil::IOBufBuilder os;
         os << "Set `" << constraint << "' to " << *value_str;
         if (use_html) {
             os << "<br><a href='/flags'>[back to flags]</a>";
@@ -187,7 +187,7 @@ void FlagsService::default_method(::google::protobuf::RpcController* cntl_base,
     std::vector<std::string> wildcards;
     std::set<std::string> exact;
     if (!constraint.empty()) {
-        for (base::StringMultiSplitter sp(constraint.c_str(), ",;"); sp != NULL; ++sp) {
+        for (butil::StringMultiSplitter sp(constraint.c_str(), ",;"); sp != NULL; ++sp) {
             std::string name(sp.field(), sp.length());
             if (name.find_first_of("$*") != std::string::npos) {
                 wildcards.push_back(name);
@@ -198,7 +198,7 @@ void FlagsService::default_method(::google::protobuf::RpcController* cntl_base,
     }
 
     // Print header of the table
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     if (use_html) {
         os << "<!DOCTYPE html><html><head>\n" << gridtable_style()
            << "<script language=\"javascript\" type=\"text/javascript\" src=\"/js/jquery_min\"></script>\n"

src/brpc/builtin/flot_min_js.cpp

@@ -15,7 +15,7 @@
 // Authors: Ge,Jun (gejun@baidu.com)
 
 #include <pthread.h>
-#include "base/logging.h"
+#include "butil/logging.h"
 #include "brpc/policy/gzip_compress.h"
 #include "brpc/builtin/flot_min_js.h"
 
@@ -23,19 +23,19 @@
 namespace brpc {
 
 static pthread_once_t s_flot_min_buf_once = PTHREAD_ONCE_INIT; 
-static base::IOBuf* s_flot_min_buf = NULL;
-static base::IOBuf* s_flot_min_buf_gzip = NULL;
+static butil::IOBuf* s_flot_min_buf = NULL;
+static butil::IOBuf* s_flot_min_buf_gzip = NULL;
 static void InitFlotMinBuf() {
-    s_flot_min_buf = new base::IOBuf;
+    s_flot_min_buf = new butil::IOBuf;
     s_flot_min_buf->append(flot_min_js());
-    s_flot_min_buf_gzip = new base::IOBuf;
+    s_flot_min_buf_gzip = new butil::IOBuf;
     CHECK(policy::GzipCompress(*s_flot_min_buf, s_flot_min_buf_gzip, NULL));
 }
-const base::IOBuf& flot_min_js_iobuf() {
+const butil::IOBuf& flot_min_js_iobuf() {
     pthread_once(&s_flot_min_buf_once, InitFlotMinBuf);
     return *s_flot_min_buf;
 }
-const base::IOBuf& flot_min_js_iobuf_gzip() {
+const butil::IOBuf& flot_min_js_iobuf_gzip() {
     pthread_once(&s_flot_min_buf_once, InitFlotMinBuf);
     return *s_flot_min_buf_gzip;
 }

src/brpc/builtin/flot_min_js.h

@@ -17,7 +17,7 @@
 #ifndef BRPC_BUILTIN_FLOT_MIN_JS_H
 #define BRPC_BUILTIN_FLOT_MIN_JS_H
 
-#include "base/iobuf.h"
+#include "butil/iobuf.h"
 
 
 namespace brpc {
@@ -26,8 +26,8 @@ namespace brpc {
 // We need to pack all js inside C++ code so that builtin services can be
 // accessed without external resources and network connection.
 const char* flot_min_js();
-const base::IOBuf& flot_min_js_iobuf();
-const base::IOBuf& flot_min_js_iobuf_gzip();
+const butil::IOBuf& flot_min_js_iobuf();
+const butil::IOBuf& flot_min_js_iobuf_gzip();
 
 } // namespace brpc
 

src/brpc/builtin/get_favicon_service.cpp

@@ -14,8 +14,8 @@
 
 // Authors: Zhangyi Chen (chenzhangyi01@baidu.com)
 
-#include "base/macros.h"                           // ARRAY_SIZE
-#include "base/iobuf.h"                            // base::IOBuf
+#include "butil/macros.h"                           // ARRAY_SIZE
+#include "butil/iobuf.h"                            // butil::IOBuf
 #include "brpc/controller.h"                   // Controller
 #include "brpc/builtin/get_favicon_service.h"
 
@@ -49,13 +49,13 @@ static unsigned char s_favicon_array[] = {
 };
 
 static pthread_once_t s_favicon_buf_once = PTHREAD_ONCE_INIT; 
-static base::IOBuf* s_favicon_buf = NULL;
+static butil::IOBuf* s_favicon_buf = NULL;
 static void InitFavIcon() {
-    s_favicon_buf = new base::IOBuf;
+    s_favicon_buf = new butil::IOBuf;
     s_favicon_buf->append((const void *)s_favicon_array, 
                           arraysize(s_favicon_array));
 }
-static const base::IOBuf& GetFavIcon() {
+static const butil::IOBuf& GetFavIcon() {
     pthread_once(&s_favicon_buf_once, InitFavIcon);
     return *s_favicon_buf;
 }

src/brpc/builtin/get_js_service.cpp

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "base/macros.h"                           // ARRAY_SIZE
-#include "base/iobuf.h"                            // base::IOBuf
+#include "butil/macros.h"                           // ARRAY_SIZE
+#include "butil/iobuf.h"                            // butil::IOBuf
 #include "brpc/controller.h"                  // Controller
 #include "brpc/builtin/sorttable_js.h"
 #include "brpc/builtin/jquery_min_js.h"

src/brpc/builtin/hotspots_service.cpp

@@ -16,8 +16,8 @@
 
 #include <stdio.h>
 #include <gflags/gflags.h>
-#include "base/files/file_enumerator.h"
-#include "base/file_util.h"                     // base::FilePath
+#include "butil/files/file_enumerator.h"
+#include "butil/file_util.h"                     // butil::FilePath
 #include "brpc/log.h"
 #include "brpc/controller.h"
 #include "brpc/server.h"
@@ -67,7 +67,7 @@ struct ProfilingClient {
     int64_t end_us;
     int seconds;
     int64_t id;
-    base::EndPoint point;
+    butil::EndPoint point;
 };
 
 struct ProfilingResult {
@@ -75,7 +75,7 @@ struct ProfilingResult {
     
     int64_t id;
     int status_code;
-    base::IOBuf result;
+    butil::IOBuf result;
 };
 
 static bool g_written_pprof_perl = false;
@@ -99,11 +99,11 @@ static ProfilingEnvironment g_env[4] = {
 // The `content' should be small so that it can be written into file in one
 // fwrite (at most time).
 static bool WriteSmallFile(const char* filepath_in,
-                           const base::StringPiece& content) {
-    base::File::Error error;
-    base::FilePath path(filepath_in);
-    base::FilePath dir = path.DirName();
-    if (!base::CreateDirectoryAndGetError(dir, &error)) {
+                           const butil::StringPiece& content) {
+    butil::File::Error error;
+    butil::FilePath path(filepath_in);
+    butil::FilePath dir = path.DirName();
+    if (!butil::CreateDirectoryAndGetError(dir, &error)) {
         LOG(ERROR) << "Fail to create directory=`" << dir.value()
                    << "', " << error;
         return false;
@@ -123,11 +123,11 @@ static bool WriteSmallFile(const char* filepath_in,
 }
 
 static bool WriteSmallFile(const char* filepath_in,
-                           const base::IOBuf& content) {
-    base::File::Error error;
-    base::FilePath path(filepath_in);
-    base::FilePath dir = path.DirName();
-    if (!base::CreateDirectoryAndGetError(dir, &error)) {
+                           const butil::IOBuf& content) {
+    butil::File::Error error;
+    butil::FilePath path(filepath_in);
+    butil::FilePath dir = path.DirName();
+    if (!butil::CreateDirectoryAndGetError(dir, &error)) {
         LOG(ERROR) << "Fail to create directory=`" << dir.value()
                    << "', " << error;
         return false;
@@ -137,7 +137,7 @@ static bool WriteSmallFile(const char* filepath_in,
         LOG(ERROR) << "Fail to open `" << path.value() << '\'';
         return false;
     }
-    base::IOBufAsZeroCopyInputStream iter(content);
+    butil::IOBufAsZeroCopyInputStream iter(content);
     const void* data = NULL;
     int size = 0;
     while (iter.Next(&data, &size)) {
@@ -182,9 +182,9 @@ static const char* GetBaseName(const std::string* full_base_name) {
 }
 
 static const char* GetBaseName(const char* full_base_name) {
-    base::StringPiece s(full_base_name);
+    butil::StringPiece s(full_base_name);
     size_t offset = s.find_last_of('/');
-    if (offset == base::StringPiece::npos) {
+    if (offset == butil::StringPiece::npos) {
         offset = 0;
     } else {
         ++offset;
@@ -196,7 +196,7 @@ static const char* GetBaseName(const char* full_base_name) {
 // NOTE: this function MUST be applied to all parameters finally passed to
 // system related functions (popen/system/exec ...) to avoid potential
 // injections from URL and other user inputs.
-static bool ValidProfilePath(const base::StringPiece& path) {
+static bool ValidProfilePath(const butil::StringPiece& path) {
     if (!path.starts_with(FLAGS_rpc_profiling_dir)) {
         // Must be under the directory.
         return false;
@@ -313,15 +313,15 @@ static void NotifyWaiters(ProfilingType type, const Controller* cur_cntl,
 static void DisplayResult(Controller* cntl,
                           google::protobuf::Closure* done,
                           const char* prof_name,
-                          const base::IOBuf& result_prefix) {
+                          const butil::IOBuf& result_prefix) {
     ClosureGuard done_guard(done);
-    base::IOBuf prof_result;
+    butil::IOBuf prof_result;
     if (cntl->IsCanceled()) {
         // If the page is refreshed, older connections are likely to be
         // already closed by browser.
         return;
     }
-    base::IOBuf& resp = cntl->response_attachment();
+    butil::IOBuf& resp = cntl->response_attachment();
     const bool use_html = UseHTML(cntl->http_request());
     const bool use_text = cntl->http_request().uri().GetQuery("text");
     const bool show_ccount = cntl->http_request().uri().GetQuery("ccount");
@@ -330,12 +330,12 @@ static void DisplayResult(Controller* cntl,
         if (!ValidProfilePath(*base_name)) {
             return cntl->SetFailed(EINVAL, "Invalid query `base'");
         }
-        if (!base::PathExists(base::FilePath(*base_name))) {
+        if (!butil::PathExists(butil::FilePath(*base_name))) {
             return cntl->SetFailed(
                 EINVAL, "The profile denoted by `base' does not exist");
         }
     }
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     os << result_prefix;
     char expected_result_name[256];
     MakeCacheName(expected_result_name, sizeof(expected_result_name),
@@ -435,8 +435,8 @@ static void DisplayResult(Controller* cntl,
         }
         if (pclose(pipe) != 0) {
             // NOTE: pclose may fail if the command failed to run, quit normal.
-            base::FilePath path(pprof_tool);
-            if (!base::PathExists(path)) {
+            butil::FilePath path(pprof_tool);
+            if (!butil::PathExists(path)) {
                 // Write the script again.
                 g_written_pprof_perl = false;
                 // tell user.
@@ -451,8 +451,8 @@ static void DisplayResult(Controller* cntl,
 
             // Append the profile name as the visual reminder for what
             // current profile is.
-            base::IOBuf before_label;
-            base::IOBuf tmp;
+            butil::IOBuf before_label;
+            butil::IOBuf tmp;
             if (cntl->http_request().uri().GetQuery("view") == NULL) {
                 tmp.append(prof_name);
                 tmp.append("[addToProfEnd]");
@@ -483,7 +483,7 @@ static void DisplayResult(Controller* cntl,
             
             if (!WriteSmallFile(result_name, prof_result)) {
                 LOG(ERROR) << "Fail to write " << result_name;
-                CHECK(base::DeleteFile(base::FilePath(result_name), false));
+                CHECK(butil::DeleteFile(butil::FilePath(result_name), false));
             }
         }
         break;
@@ -506,11 +506,11 @@ static void DoProfiling(ProfilingType type,
                         ::google::protobuf::Closure* done) {
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);
-    base::IOBuf& resp = cntl->response_attachment();
+    butil::IOBuf& resp = cntl->response_attachment();
     const bool use_html = UseHTML(cntl->http_request());
     cntl->http_response().set_content_type(use_html ? "text/html" : "text/plain");
 
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     if (use_html) {
         os << "<!DOCTYPE html><html><head>\n"
             "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n"
@@ -530,7 +530,7 @@ static void DoProfiling(ProfilingType type,
         if (!ValidProfilePath(*view)) {
             return cntl->SetFailed(EINVAL, "Invalid query `view'");
         }
-        if (!base::PathExists(base::FilePath(*view))) {
+        if (!butil::PathExists(butil::FilePath(*view))) {
             return cntl->SetFailed(
                 EINVAL, "The profile denoted by `view' does not exist");
         }
@@ -592,7 +592,7 @@ static void DoProfiling(ProfilingType type,
         }
         CHECK(NULL == g_env[type].client);
         g_env[type].client = new ProfilingClient;
-        g_env[type].client->end_us = base::cpuwide_time_us() + seconds * 1000000L;
+        g_env[type].client->end_us = butil::cpuwide_time_us() + seconds * 1000000L;
         g_env[type].client->seconds = seconds;
         // This id work arounds an issue of chrome (or jquery under chrome) that
         // the ajax call in another tab may be delayed until ajax call in
@@ -627,9 +627,9 @@ static void DoProfiling(ProfilingType type,
             cntl->http_response().set_status_code(HTTP_STATUS_FORBIDDEN);
             return NotifyWaiters(type, cntl, view);
         }
-        base::File::Error error;
-        const base::FilePath dir = base::FilePath(prof_name).DirName();
-        if (!base::CreateDirectoryAndGetError(dir, &error)) {
+        butil::File::Error error;
+        const butil::FilePath dir = butil::FilePath(prof_name).DirName();
+        if (!butil::CreateDirectoryAndGetError(dir, &error)) {
             os << "Fail to create directory=`" << dir.value() << ", "
                << error << (use_html ? "</body></html>" : "\n");
             os.move_to(resp);
@@ -721,9 +721,9 @@ static void StartProfiling(ProfilingType type,
                            ::google::protobuf::Closure* done) {
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);
-    base::IOBuf& resp = cntl->response_attachment();
+    butil::IOBuf& resp = cntl->response_attachment();
     const bool use_html = UseHTML(cntl->http_request());
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     bool enabled = false;
     if (type == PROFILING_CPU) {
         enabled = cpu_profiler_enabled;
@@ -903,17 +903,17 @@ static void StartProfiling(ProfilingType type,
 
     TRACEPRINTF("Begin to enumerate profiles");
     std::vector<std::string> past_profs;
-    base::FilePath prof_dir(FLAGS_rpc_profiling_dir);
+    butil::FilePath prof_dir(FLAGS_rpc_profiling_dir);
     prof_dir = prof_dir.Append(GetProgramChecksum());
     std::string file_pattern;
     file_pattern.reserve(15);
     file_pattern.append("*.");
     file_pattern.append(type_str);
-    base::FileEnumerator prof_enum(prof_dir, false/*non recursive*/,
-                                   base::FileEnumerator::FILES,
+    butil::FileEnumerator prof_enum(prof_dir, false/*non recursive*/,
+                                   butil::FileEnumerator::FILES,
                                    file_pattern);
     std::string file_path;
-    for (base::FilePath name = prof_enum.Next(); !name.empty();
+    for (butil::FilePath name = prof_enum.Next(); !name.empty();
          name = prof_enum.Next()) {
         // NOTE: name already includes dir.
         if (past_profs.empty()) {
@@ -932,12 +932,12 @@ static void StartProfiling(ProfilingType type,
             TRACEPRINTF("Remove %lu profiles",
                         past_profs.size() - (size_t)max_profiles);
             for (size_t i = max_profiles; i < past_profs.size(); ++i) {
-                CHECK(base::DeleteFile(base::FilePath(past_profs[i]), false));
+                CHECK(butil::DeleteFile(butil::FilePath(past_profs[i]), false));
                 std::string cache_path;
                 cache_path.reserve(past_profs[i].size() + 7);
                 cache_path += past_profs[i];
                 cache_path += ".cache";
-                CHECK(base::DeleteFile(base::FilePath(cache_path), true));
+                CHECK(butil::DeleteFile(butil::FilePath(cache_path), true));
             }
             past_profs.resize(max_profiles);
         }
@@ -1009,7 +1009,7 @@ static void StartProfiling(ProfilingType type,
     os << "<div id=\"profiling-result\">";
     if (profiling_client.seconds != 0) {
         const int wait_seconds =
-            (int)ceil((profiling_client.end_us - base::cpuwide_time_us())
+            (int)ceil((profiling_client.end_us - butil::cpuwide_time_us())
                       / 1000000.0);
         os << "Your request is merged with the request from "
            << profiling_client.point;

src/brpc/builtin/ids_service.cpp

@@ -35,7 +35,7 @@ void IdsService::default_method(::google::protobuf::RpcController* cntl_base,
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);
     cntl->http_response().set_content_type("text/plain");
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     const std::string& constraint = cntl->http_request().unresolved_path();
     
     if (constraint.empty()) {

src/brpc/builtin/index_service.cpp

@@ -16,7 +16,7 @@
 
 #include <gflags/gflags.h>                  // DECLARE_xxx
 #include <google/protobuf/descriptor.h>
-#include "base/time.h"                      // gettimeofday_us
+#include "butil/time.h"                      // gettimeofday_us
 #include "brpc/server.h"                    // Server
 #include "brpc/builtin/index_service.h"
 #include "brpc/builtin/status_service.h"
@@ -46,7 +46,7 @@ void IndexService::default_method(::google::protobuf::RpcController* controller,
     Controller *cntl = (Controller*)controller;
     cntl->http_response().set_content_type("text/plain");
     const Server* server = cntl->server();
-    const base::EndPoint my_addr(base::my_ip(),
+    const butil::EndPoint my_addr(butil::my_ip(),
                                  server->listen_address().port);
     const bool use_html = UseHTML(cntl->http_request());
     const bool as_more = cntl->http_request().uri().GetQuery("as_more");
@@ -62,11 +62,11 @@ void IndexService::default_method(::google::protobuf::RpcController* controller,
     }
     cntl->http_response().set_content_type(
         use_html ? "text/html" : "text/plain");
-    const base::EndPoint* const html_addr = (use_html ? Path::LOCAL : NULL);
+    const butil::EndPoint* const html_addr = (use_html ? Path::LOCAL : NULL);
     const char* const NL = (use_html ? "<br>\n" : "\n");
     const char* const SP = (use_html ? "&nbsp;" : "  ");
 
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     if (use_html) {
         os << "<!DOCTYPE html><html>";
         if (as_more) {
@@ -115,7 +115,7 @@ void IndexService::default_method(::google::protobuf::RpcController* controller,
            << SP << Path("/rpcz/stats", html_addr) << " : Statistics of rpcz" << NL;
 
         std::ostringstream tmp_oss;
-        const int64_t seconds_before = base::gettimeofday_us() - 30 * 1000000L;
+        const int64_t seconds_before = butil::gettimeofday_us() - 30 * 1000000L;
         tmp_oss << "/rpcz?" << TIME_STR << '=';
         PrintRealDateTime(tmp_oss, seconds_before, true);
         os << SP << Path(tmp_oss.str().c_str(), html_addr)

src/brpc/builtin/jquery_min_js.cpp

@@ -15,7 +15,7 @@
 // Authors: Ge,Jun (gejun@baidu.com)
 
 #include <pthread.h>
-#include "base/logging.h"
+#include "butil/logging.h"
 #include "brpc/policy/gzip_compress.h"
 #include "brpc/builtin/jquery_min_js.h"
 
@@ -23,19 +23,19 @@
 namespace brpc {
 
 static pthread_once_t s_jquery_min_buf_once = PTHREAD_ONCE_INIT; 
-static base::IOBuf* s_jquery_min_buf = NULL;
-static base::IOBuf* s_jquery_min_buf_gzip = NULL;
+static butil::IOBuf* s_jquery_min_buf = NULL;
+static butil::IOBuf* s_jquery_min_buf_gzip = NULL;
 static void InitJQueryMinBuf() {
-    s_jquery_min_buf = new base::IOBuf;
+    s_jquery_min_buf = new butil::IOBuf;
     s_jquery_min_buf->append(jquery_min_js());
-    s_jquery_min_buf_gzip = new base::IOBuf;
+    s_jquery_min_buf_gzip = new butil::IOBuf;
     CHECK(policy::GzipCompress(*s_jquery_min_buf, s_jquery_min_buf_gzip, NULL));
 }
-const base::IOBuf& jquery_min_js_iobuf() {
+const butil::IOBuf& jquery_min_js_iobuf() {
     pthread_once(&s_jquery_min_buf_once, InitJQueryMinBuf);
     return *s_jquery_min_buf;
 }
-const base::IOBuf& jquery_min_js_iobuf_gzip() {
+const butil::IOBuf& jquery_min_js_iobuf_gzip() {
     pthread_once(&s_jquery_min_buf_once, InitJQueryMinBuf);
     return *s_jquery_min_buf_gzip;
 }

src/brpc/builtin/jquery_min_js.h

@@ -17,7 +17,7 @@
 #ifndef BRPC_BUILTIN_JQUERY_MIN_JS_H
 #define BRPC_BUILTIN_JQUERY_MIN_JS_H
 
-#include "base/iobuf.h"
+#include "butil/iobuf.h"
 
 
 namespace brpc {
@@ -26,8 +26,8 @@ namespace brpc {
 // We need to pack all js inside C++ code so that builtin services can be
 // accessed without external resources and network connection.
 const char* jquery_min_js();
-const base::IOBuf& jquery_min_js_iobuf();
-const base::IOBuf& jquery_min_js_iobuf_gzip();
+const butil::IOBuf& jquery_min_js_iobuf();
+const butil::IOBuf& jquery_min_js_iobuf_gzip();
 
 } // namespace brpc
 

src/brpc/builtin/pprof_service.cpp

@@ -18,18 +18,18 @@
 #include <limits>
 #include <sys/stat.h>
 #include <fcntl.h>                          // O_RDONLY
-#include "base/string_printf.h"             // string_printf
-#include "base/string_splitter.h"           // StringSplitter
-#include "base/file_util.h"                 // base::FilePath
-#include "base/files/scoped_file.h"         // ScopedFILE
-#include "base/time.h"
+#include "butil/string_printf.h"             // string_printf
+#include "butil/string_splitter.h"           // StringSplitter
+#include "butil/file_util.h"                 // butil::FilePath
+#include "butil/files/scoped_file.h"         // ScopedFILE
+#include "butil/time.h"
 #include "brpc/log.h"
 #include "brpc/controller.h"                // Controller
 #include "brpc/closure_guard.h"             // ClosureGuard
 #include "brpc/builtin/pprof_service.h"
 #include "brpc/builtin/common.h"
 #include "bthread/bthread.h"                // bthread_usleep
-#include "base/fd_guard.h"
+#include "butil/fd_guard.h"
 
 extern "C" {
 extern char *program_invocation_name;
@@ -123,9 +123,9 @@ void PProfService::profile(
         cntl->SetFailed(errno, "Fail to create .prof file, %s", berror());
         return;
     }
-    base::File::Error error;
-    const base::FilePath dir = base::FilePath(prof_name).DirName();
-    if (!base::CreateDirectoryAndGetError(dir, &error)) {
+    butil::File::Error error;
+    const butil::FilePath dir = butil::FilePath(prof_name).DirName();
+    if (!butil::CreateDirectoryAndGetError(dir, &error)) {
         cntl->SetFailed(EPERM, "Fail to create directory=`%s'",dir.value().c_str());
         return;
     }
@@ -138,12 +138,12 @@ void PProfService::profile(
     }
     ProfilerStop();
 
-    base::fd_guard fd(open(prof_name, O_RDONLY));
+    butil::fd_guard fd(open(prof_name, O_RDONLY));
     if (fd < 0) {
         cntl->SetFailed(ENOENT, "Fail to open %s", prof_name);
         return;
     }
-    base::IOPortal portal;
+    butil::IOPortal portal;
     portal.append_from_file_descriptor(fd, ULONG_MAX);
     cntl->response_attachment().swap(portal);
 }
@@ -187,12 +187,12 @@ void PProfService::contention(
     }
     bthread::ContentionProfilerStop();
 
-    base::fd_guard fd(open(prof_name, O_RDONLY));
+    butil::fd_guard fd(open(prof_name, O_RDONLY));
     if (fd < 0) {
         cntl->SetFailed(ENOENT, "Fail to open %s", prof_name);
         return;
     }
-    base::IOPortal portal;
+    butil::IOPortal portal;
     portal.append_from_file_descriptor(fd, ULONG_MAX);
     cntl->response_attachment().swap(portal);
 }
@@ -275,7 +275,7 @@ static bool HasExt(const std::string& name, const std::string& ext) {
 static int ExtractSymbolsFromBinary(
     std::map<uintptr_t, std::string>& addr_map,
     const LibInfo& lib_info) {
-    base::Timer tm;
+    butil::Timer tm;
     tm.start();
     std::string cmd = "nm -C -p ";
     cmd.append(lib_info.path);
@@ -288,7 +288,7 @@ static int ExtractSymbolsFromBinary(
     size_t line_len = 0;
     ssize_t nr = 0;
     while ((nr = getline(&line, &line_len, pipe)) != -1) {
-        base::StringSplitter sp(line, ' ');
+        butil::StringSplitter sp(line, ' ');
         if (sp == NULL) {
             continue;
         }
@@ -379,9 +379,9 @@ static int ExtractSymbolsFromBinary(
 }
 
 static void LoadSymbols() {
-    base::Timer tm;
+    butil::Timer tm;
     tm.start();
-    base::ScopedFILE fp(fopen("/proc/self/maps", "r"));
+    butil::ScopedFILE fp(fopen("/proc/self/maps", "r"));
     if (fp == NULL) {
         return;
     }
@@ -389,7 +389,7 @@ static void LoadSymbols() {
     size_t line_len = 0;
     ssize_t nr = 0;
     while ((nr = getline(&line, &line_len, fp.get())) != -1) {
-        base::StringSplitter sp(line, line + line_len, ' ');
+        butil::StringSplitter sp(line, line + line_len, ' ');
         if (sp == NULL) {
             continue;
         }
@@ -448,7 +448,7 @@ static void LoadSymbols() {
     info.path = program_invocation_name;
     ExtractSymbolsFromBinary(symbol_map, info);
 
-    base::Timer tm2;
+    butil::Timer tm2;
     tm2.start();
     size_t num_removed = 0;
     bool last_is_empty = false;
@@ -474,7 +474,7 @@ static void LoadSymbols() {
     RPC_VLOG << "Loaded all symbols in " << tm.m_elapsed() << "ms";
 }
 
-static void FindSymbols(base::IOBuf* out, std::vector<uintptr_t>& addr_list) {
+static void FindSymbols(butil::IOBuf* out, std::vector<uintptr_t>& addr_list) {
     char buf[32];
     for (size_t i = 0; i < addr_list.size(); ++i) {
         int len = snprintf(buf, sizeof(buf), "0x%08lx\t", addr_list[i]);
@@ -525,7 +525,7 @@ void PProfService::symbol(
         }
         std::vector<uintptr_t> addr_list;
         addr_list.reserve(32);
-        base::StringSplitter sp(addr_cstr, '+');
+        butil::StringSplitter sp(addr_cstr, '+');
         for ( ; sp != NULL; ++sp) {
             char* endptr;
             uintptr_t addr = strtoull(sp.field(), &endptr, 16);

src/brpc/builtin/protobufs_service.cpp

@@ -72,7 +72,7 @@ void ProtobufsService::default_method(::google::protobuf::RpcController* cntl_ba
                                    ::google::protobuf::Closure* done) {
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     const std::string& filter = cntl->http_request().unresolved_path();
     if (filter.empty()) {
         const bool use_html = UseHTML(cntl->http_request());

src/brpc/builtin/rpcz_service.cpp

@@ -17,10 +17,10 @@
 #include <ostream>
 #include <iomanip>
 #include <gflags/gflags.h>
-#include "base/string_printf.h"
-#include "base/string_splitter.h"
-#include "base/macros.h"
-#include "base/time.h"
+#include "butil/string_printf.h"
+#include "butil/string_splitter.h"
+#include "butil/macros.h"
+#include "butil/time.h"
 #include "brpc/closure_guard.h"        // ClosureGuard
 #include "brpc/controller.h"           // Controller
 #include "brpc/builtin/common.h"
@@ -149,7 +149,7 @@ void RpczService::stats(::google::protobuf::RpcController* cntl_base,
         return;
     }
 
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     DescribeSpanDB(os);
     os.move_to(cntl->response_attachment());
 }
@@ -193,7 +193,7 @@ static void PrintAnnotations(
             PrintRealTime(os, anno_time);
             PrintElapse(os, anno_time, last_time);
             os << ' ' << a;
-            if (a.empty() || base::back_char(a) != '\n') {
+            if (a.empty() || butil::back_char(a) != '\n') {
                 os << '\n';
             }
         }
@@ -224,8 +224,8 @@ struct CompareByStartRealTime {
     }
 };
 
-static base::ip_t loopback_ip = base::IP_ANY;
-static int ALLOW_UNUSED init_loopback_ip_dummy = base::str2ip("127.0.0.1", &loopback_ip);
+static butil::ip_t loopback_ip = butil::IP_ANY;
+static int ALLOW_UNUSED init_loopback_ip_dummy = butil::str2ip("127.0.0.1", &loopback_ip);
 
 static void PrintClientSpan(
     std::ostream& os, const RpczSpan& span,
@@ -242,10 +242,10 @@ static void PrintClientSpan(
                                           last_time, extr, num_extr));
     const Protocol* protocol = FindProtocol(span.protocol());
     const char* protocol_name = (protocol ? protocol->name : "Unknown");
-    const base::EndPoint remote_side(base::int2ip(span.remote_ip()), span.remote_port());
-    base::EndPoint abs_remote_side = remote_side;
+    const butil::EndPoint remote_side(butil::int2ip(span.remote_ip()), span.remote_port());
+    butil::EndPoint abs_remote_side = remote_side;
     if (abs_remote_side.ip == loopback_ip) {
-        abs_remote_side.ip = base::my_ip();
+        abs_remote_side.ip = butil::my_ip();
     }
     os << " Requesting " << span.full_method_name() << '@' << remote_side
        << ' ' << protocol_name << ' ' << LOG_ID_STR << '=';
@@ -313,8 +313,8 @@ static void PrintServerSpan(std::ostream& os, const RpczSpan& span,
     SpanInfoExtractor server_extr(span.info().c_str());
     SpanInfoExtractor* extr[1] = { &server_extr };
     int64_t last_time = span.received_real_us();
-    const base::EndPoint remote_side(
-        base::int2ip(span.remote_ip()), span.remote_port());
+    const butil::EndPoint remote_side(
+        butil::int2ip(span.remote_ip()), span.remote_port());
     PrintRealDateTime(os, last_time);
     const Protocol* protocol = FindProtocol(span.protocol());
     const char* protocol_name = (protocol ? protocol->name : "Unknown");
@@ -481,7 +481,7 @@ void RpczService::default_method(::google::protobuf::RpcController* cntl_base,
     cntl->http_response().set_content_type(
         use_html ? "text/html" : "text/plain");
 
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     if (use_html) {
         os << "<!DOCTYPE html><html><head>\n"
            << "<script language=\"javascript\" type=\"text/javascript\" src=\"/js/jquery_min\"></script>\n"
@@ -503,7 +503,7 @@ void RpczService::default_method(::google::protobuf::RpcController* cntl_base,
         os.move_to(cntl->response_attachment());
         return;
     }
-    base::EndPoint my_addr(base::my_ip(),
+    butil::EndPoint my_addr(butil::my_ip(),
                            cntl->server()->listen_address().port);
     
     const std::string* trace_id_str =
@@ -564,7 +564,7 @@ void RpczService::default_method(::google::protobuf::RpcController* cntl_base,
             cntl->http_request().uri().GetQuery(TIME_STR);
         int64_t start_tm;
         if (time_str == NULL) {
-            start_tm = base::gettimeofday_us();
+            start_tm = butil::gettimeofday_us();
         } else {
             start_tm = ParseDateTime(*time_str);
             if (start_tm < 0) {

src/brpc/builtin/sockets_service.cpp

@@ -31,12 +31,12 @@ void SocketsService::default_method(::google::protobuf::RpcController* cntl_base
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);
     cntl->http_response().set_content_type("text/plain");
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     const std::string& constraint = cntl->http_request().unresolved_path();
     
     if (constraint.empty()) {
         os << "# Use /sockets/<SocketId>\n"
-           << base::describe_resources<Socket>() << '\n';
+           << butil::describe_resources<Socket>() << '\n';
     } else {
         char* endptr = NULL;
         SocketId sid = strtoull(constraint.c_str(), &endptr, 10);

src/brpc/builtin/sorttable_js.cpp

@@ -21,12 +21,12 @@
 namespace brpc {
 
 static pthread_once_t s_sorttable_buf_once = PTHREAD_ONCE_INIT; 
-static base::IOBuf* s_sorttable_buf = NULL;
+static butil::IOBuf* s_sorttable_buf = NULL;
 static void InitSortTableBuf() {
-    s_sorttable_buf = new base::IOBuf;
+    s_sorttable_buf = new butil::IOBuf;
     s_sorttable_buf->append(sorttable_js());
 }
-const base::IOBuf& sorttable_js_iobuf() {
+const butil::IOBuf& sorttable_js_iobuf() {
     pthread_once(&s_sorttable_buf_once, InitSortTableBuf);
     return *s_sorttable_buf;
 }
@@ -469,7 +469,7 @@ const char* sorttable_js() {
 "  this.cancelBubble = true;\n"
 "}\n"
 "\n"
-"// Dean's forEach: http://dean.edwards.name/base/forEach.js\n"
+"// Dean's forEach: http://dean.edwards.name/butil/forEach.js\n"
 "/*\n"
 "    forEach, version 1.0\n"
 "    Copyright 2006, Dean Edwards\n"

src/brpc/builtin/sorttable_js.h

@@ -17,7 +17,7 @@
 #ifndef BRPC_BUILTIN_SORTTABLE_JS_H
 #define BRPC_BUILTIN_SORTTABLE_JS_H
 
-#include "base/iobuf.h"
+#include "butil/iobuf.h"
 
 
 namespace brpc {
@@ -26,7 +26,7 @@ namespace brpc {
 // We need to pack all js inside C++ code so that builtin services can be
 // accessed without external resources and network connection.
 const char* sorttable_js();
-const base::IOBuf& sorttable_js_iobuf();
+const butil::IOBuf& sorttable_js_iobuf();
 
 } // namespace brpc
 

src/brpc/builtin/status_service.cpp

@@ -48,7 +48,7 @@ void StatusService::default_method(::google::protobuf::RpcController* cntl_base,
     // can load values more easily.
     cntl->http_response().set_content_type(
         use_html ? "text/html" : "text/plain");
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     std::string str;
     if (use_html) {
         os << "<!DOCTYPE html><html><head>\n"

src/brpc/builtin/threads_service.cpp

@@ -14,13 +14,13 @@
 
 // Authors: Ge,Jun (gejun@baidu.com)
 
-#include "base/time.h"
-#include "base/logging.h"
+#include "butil/time.h"
+#include "butil/logging.h"
 #include "brpc/controller.h"           // Controller
 #include "brpc/closure_guard.h"        // ClosureGuard
 #include "brpc/builtin/threads_service.h"
 #include "brpc/builtin/common.h"
-#include "base/string_printf.h"
+#include "butil/string_printf.h"
 
 namespace brpc {
 
@@ -31,11 +31,11 @@ void ThreadsService::default_method(::google::protobuf::RpcController* cntl_base
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);
     cntl->http_response().set_content_type("text/plain");
-    base::IOBuf& resp = cntl->response_attachment();
+    butil::IOBuf& resp = cntl->response_attachment();
 
-    base::IOPortal read_portal;
-    std::string cmd = base::string_printf("pstack %lld", (long long)getpid());
-    base::Timer tm;
+    butil::IOPortal read_portal;
+    std::string cmd = butil::string_printf("pstack %lld", (long long)getpid());
+    butil::Timer tm;
     tm.start();
     FILE* pipe = popen(cmd.c_str(), "r");
     if (pipe == NULL) {
@@ -50,10 +50,10 @@ void ThreadsService::default_method(::google::protobuf::RpcController* cntl_base
     // and pclose will fail:
     //   CHECK failed: 0 == pclose(pipe): Resource temporarily unavailable
     size_t fake_buf;
-    base::ignore_result(fread(&fake_buf, sizeof(fake_buf), 1, pipe));
+    butil::ignore_result(fread(&fake_buf, sizeof(fake_buf), 1, pipe));
     CHECK_EQ(0, pclose(pipe)) << berror();
     tm.stop();
-    resp.append(base::string_printf("\n\ntime=%lums", tm.m_elapsed()));
+    resp.append(butil::string_printf("\n\ntime=%lums", tm.m_elapsed()));
 }
 
 } // namespace brpc

src/brpc/builtin/vars_service.cpp

@@ -16,7 +16,7 @@
 
 #include <ostream>
 #include <vector>                           // std::vector
-#include "base/string_splitter.h"
+#include "butil/string_splitter.h"
 #include "bvar/bvar.h"
 
 #include "brpc/closure_guard.h"        // ClosureGuard
@@ -258,10 +258,10 @@ static const std::string VAR_SEP = " : ";
 
 class VarsDumper : public bvar::Dumper {
 public:
-    explicit VarsDumper(base::IOBufBuilder& os, bool use_html)
+    explicit VarsDumper(butil::IOBufBuilder& os, bool use_html)
         : _os(os), _use_html(use_html) {}
     
-    bool dump(const std::string& name, const base::StringPiece& desc) {
+    bool dump(const std::string& name, const butil::StringPiece& desc) {
         bool plot = false;
         if (_use_html) {
             bvar::SeriesOptions series_options;
@@ -292,14 +292,14 @@ public:
         return true;
     }
 
-    void move_to(base::IOBuf& buf) {
+    void move_to(butil::IOBuf& buf) {
         _os.move_to(buf);
     }
     
 private:
     DISALLOW_COPY_AND_ASSIGN(VarsDumper);
     
-    base::IOBufBuilder & _os;
+    butil::IOBufBuilder & _os;
     bool _use_html;
 };
 
@@ -310,7 +310,7 @@ void VarsService::default_method(::google::protobuf::RpcController* cntl_base,
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);    
     if (cntl->http_request().uri().GetQuery("series") != NULL) {
-        base::IOBufBuilder os;
+        butil::IOBufBuilder os;
         bvar::SeriesOptions series_options;
         const int rc = bvar::Variable::describe_series_exposed(
             cntl->http_request().unresolved_path(), os, series_options);
@@ -336,7 +336,7 @@ void VarsService::default_method(::google::protobuf::RpcController* cntl_base,
     cntl->http_response().set_content_type(
         use_html ? "text/html" : "text/plain");
 
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
     if (with_tabs) {
         os << "<!DOCTYPE html><html><head>\n"
             "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n";

src/brpc/builtin/viz_min_js.cpp

@@ -15,7 +15,7 @@
 // Authors: Ge,Jun (gejun@baidu.com)
 
 #include <pthread.h>
-#include "base/logging.h"
+#include "butil/logging.h"
 #include "brpc/policy/gzip_compress.h"
 #include "brpc/builtin/viz_min_js.h"
 
@@ -23,12 +23,12 @@
 namespace brpc {
 
 static pthread_once_t s_viz_min_buf_once = PTHREAD_ONCE_INIT; 
-static base::IOBuf* s_viz_min_buf = NULL;
+static butil::IOBuf* s_viz_min_buf = NULL;
 static void InitVizMinBuf() {
-    s_viz_min_buf = new base::IOBuf;
+    s_viz_min_buf = new butil::IOBuf;
     s_viz_min_buf->append(viz_min_js());
 }
-const base::IOBuf& viz_min_js_iobuf() {
+const butil::IOBuf& viz_min_js_iobuf() {
     pthread_once(&s_viz_min_buf_once, InitVizMinBuf);
     return *s_viz_min_buf;
 }
@@ -36,14 +36,14 @@ const base::IOBuf& viz_min_js_iobuf() {
 // viz.js is huge. We separate the creation of gzip version from uncompress
 // version so that at most time we only keep gzip version in memory.
 static pthread_once_t s_viz_min_buf_gzip_once = PTHREAD_ONCE_INIT; 
-static base::IOBuf* s_viz_min_buf_gzip = NULL;
+static butil::IOBuf* s_viz_min_buf_gzip = NULL;
 static void InitVizMinBufGzip() {
-    base::IOBuf viz_min;
+    butil::IOBuf viz_min;
     viz_min.append(viz_min_js());
-    s_viz_min_buf_gzip = new base::IOBuf;
+    s_viz_min_buf_gzip = new butil::IOBuf;
     CHECK(policy::GzipCompress(viz_min, s_viz_min_buf_gzip, NULL));
 }
-const base::IOBuf& viz_min_js_iobuf_gzip() {
+const butil::IOBuf& viz_min_js_iobuf_gzip() {
     pthread_once(&s_viz_min_buf_gzip_once, InitVizMinBufGzip);
     return *s_viz_min_buf_gzip;
 }

src/brpc/builtin/viz_min_js.h

@@ -17,7 +17,7 @@
 #ifndef BRPC_BUILTIN_VIZ_MIN_JS_H
 #define BRPC_BUILTIN_VIZ_MIN_JS_H
 
-#include "base/iobuf.h"
+#include "butil/iobuf.h"
 
 
 namespace brpc {
@@ -26,8 +26,8 @@ namespace brpc {
 // We need to pack all js inside C++ code so that builtin services can be
 // accessed without external resources and network connection.
 const char* viz_min_js();
-const base::IOBuf& viz_min_js_iobuf();
-const base::IOBuf& viz_min_js_iobuf_gzip();
+const butil::IOBuf& viz_min_js_iobuf();
+const butil::IOBuf& viz_min_js_iobuf_gzip();
 
 } // namespace brpc
 

src/brpc/builtin/vlog_service.cpp

@@ -65,7 +65,7 @@ void VLogService::default_method(::google::protobuf::RpcController* cntl_base,
     ClosureGuard done_guard(done);
     Controller *cntl = static_cast<Controller*>(cntl_base);
     const bool use_html = UseHTML(cntl->http_request());
-    base::IOBufBuilder os;
+    butil::IOBufBuilder os;
 
     cntl->http_response().set_content_type(
         use_html ? "text/html" : "text/plain");

src/brpc/channel.cpp

@@ -18,8 +18,8 @@
 
 #include <google/protobuf/descriptor.h>
 #include <gflags/gflags.h>
-#include "base/time.h"                               // milliseconds_from_now
-#include "base/logging.h"
+#include "butil/time.h"                               // milliseconds_from_now
+#include "butil/logging.h"
 #include "bthread/unstable.h"                        // bthread_timer_add
 #include "brpc/socket_map.h"                    // SocketMapInsert
 #include "brpc/compress.h"
@@ -128,7 +128,7 @@ int Channel::InitChannelOptions(const ChannelOptions* options) {
 int Channel::Init(const char* server_addr_and_port,
                   const ChannelOptions* options) {
     GlobalInitializeOrDie();
-    base::EndPoint point;
+    butil::EndPoint point;
     const Protocol* protocol =
         FindProtocol(options ? options->protocol : _options.protocol);
     if (protocol != NULL && protocol->parse_server_address != NULL) {
@@ -157,7 +157,7 @@ int Channel::Init(const char* server_addr_and_port,
 int Channel::Init(const char* server_addr, int port,
                   const ChannelOptions* options) {
     GlobalInitializeOrDie();
-    base::EndPoint point;
+    butil::EndPoint point;
     const Protocol* protocol =
         FindProtocol(options ? options->protocol : _options.protocol);
     if (protocol != NULL && protocol->parse_server_address != NULL) {
@@ -176,7 +176,7 @@ int Channel::Init(const char* server_addr, int port,
     return Init(point, options);
 }
 
-int Channel::Init(base::EndPoint server_addr_and_port,
+int Channel::Init(butil::EndPoint server_addr_and_port,
                   const ChannelOptions* options) {
     GlobalInitializeOrDie();
     if (InitChannelOptions(options) != 0) {
@@ -265,7 +265,7 @@ void Channel::CallMethod(const google::protobuf::MethodDescriptor* method,
                          const google::protobuf::Message* request,
                          google::protobuf::Message* response,
                          google::protobuf::Closure* done) {
-    const int64_t start_send_real_us = base::gettimeofday_us();
+    const int64_t start_send_real_us = butil::gettimeofday_us();
     Controller* cntl = static_cast<Controller*>(controller_base);
     cntl->OnRPCBegin(start_send_real_us);
     // Override max_retry first to reset the range of correlation_id
@@ -297,7 +297,7 @@ void Channel::CallMethod(const google::protobuf::MethodDescriptor* method,
         return;
     }
     if (cntl->_sender == NULL && IsTraceable(Span::tls_parent())) {
-        const int64_t start_send_us = base::cpuwide_time_us();
+        const int64_t start_send_us = butil::cpuwide_time_us();
         const std::string* method_name = NULL;
         if (_get_method_name) {
             method_name = &_get_method_name(method, cntl);
@@ -378,7 +378,7 @@ void Channel::CallMethod(const google::protobuf::MethodDescriptor* method,
         }
         const int rc = bthread_timer_add(
             &cntl->_timeout_id,
-            base::microseconds_to_timespec(
+            butil::microseconds_to_timespec(
                 cntl->backup_request_ms() * 1000L + start_send_real_us),
             HandleBackupRequest, (void*)correlation_id.value);
         if (BAIDU_UNLIKELY(rc != 0)) {
@@ -392,7 +392,7 @@ void Channel::CallMethod(const google::protobuf::MethodDescriptor* method,
         cntl->_abstime_us = cntl->timeout_ms() * 1000L + start_send_real_us;
         const int rc = bthread_timer_add(
             &cntl->_timeout_id,
-            base::microseconds_to_timespec(cntl->_abstime_us),
+            butil::microseconds_to_timespec(cntl->_abstime_us),
             HandleTimeout, (void*)correlation_id.value);
         if (BAIDU_UNLIKELY(rc != 0)) {
             cntl->SetFailed(rc, "Fail to add timer for timeout");
@@ -411,7 +411,7 @@ void Channel::CallMethod(const google::protobuf::MethodDescriptor* method,
         if (cntl->_span) {
             cntl->SubmitSpan();
         }
-        cntl->OnRPCEnd(base::gettimeofday_us());
+        cntl->OnRPCEnd(butil::gettimeofday_us());
     }
 }
 

src/brpc/channel.h

@@ -23,7 +23,7 @@
 
 #include <ostream>                               // std::ostream
 #include "bthread/errno.h"                       // Redefine errno
-#include "base/intrusive_ptr.hpp"               // base::intrusive_ptr
+#include "butil/intrusive_ptr.hpp"               // butil::intrusive_ptr
 #include "brpc/channel_base.h"              // ChannelBase
 #include "brpc/adaptive_protocol_type.h"    // AdaptiveProtocolType
 #include "brpc/adaptive_connection_type.h"  // AdaptiveConnectionType
@@ -126,7 +126,7 @@ public:
 
     // Connect this channel to a single server whose address is given by the
     // first parameter. Use default options if `options' is NULL.
-    int Init(base::EndPoint server_addr_and_port, const ChannelOptions* options);
+    int Init(butil::EndPoint server_addr_and_port, const ChannelOptions* options);
     int Init(const char* server_addr_and_port, const ChannelOptions* options);
     int Init(const char* server_addr, int port, const ChannelOptions* options);
 
@@ -185,7 +185,7 @@ protected:
 
     int InitChannelOptions(const ChannelOptions* options);
 
-    base::EndPoint _server_address;
+    butil::EndPoint _server_address;
     SocketId _server_id;
     Protocol::SerializeRequest _serialize_request;
     Protocol::PackRequest _pack_request;
@@ -194,7 +194,7 @@ protected:
     // are in the middle of RPC procedure using this channel.
     // It will be destroyed after channel's destruction and all
     // the RPC above has finished
-    base::intrusive_ptr<SharedLoadBalancer> _lb;
+    butil::intrusive_ptr<SharedLoadBalancer> _lb;
     ChannelOptions _options;
     int _preferred_index;
 };

src/brpc/channel_base.h

@@ -19,7 +19,7 @@
 
 #include <stdlib.h>
 #include <ostream>
-#include "base/logging.h"
+#include "butil/logging.h"
 #include <google/protobuf/service.h>            // google::protobuf::RpcChannel
 #include "brpc/describable.h"
 

src/brpc/closure_guard.h

@@ -18,7 +18,7 @@
 #define BRPC_CLOSURE_GUARD_H
 
 #include <google/protobuf/service.h>
-#include "base/macros.h"
+#include "butil/macros.h"
 
 
 namespace brpc {

src/brpc/compress.cpp

@@ -15,7 +15,7 @@
 // Authors: Rujie Jiang (jiangrujie@baidu.com)
 //          Ge,Jun (gejun@baidu.com)
 
-#include "base/logging.h"
+#include "butil/logging.h"
 #include "brpc/compress.h"
 #include "brpc/protocol.h"
 
@@ -75,7 +75,7 @@ void ListCompressHandler(std::vector<CompressHandler>* vec) {
     }
 }
 
-bool ParseFromCompressedData(const base::IOBuf& data, 
+bool ParseFromCompressedData(const butil::IOBuf& data, 
                              google::protobuf::Message* msg,
                              CompressType compress_type) {
     if (compress_type == COMPRESS_TYPE_NONE) {
@@ -89,9 +89,9 @@ bool ParseFromCompressedData(const base::IOBuf& data,
 }
 
 bool SerializeAsCompressedData(const google::protobuf::Message& msg,
-                               base::IOBuf* buf, CompressType compress_type) {
+                               butil::IOBuf* buf, CompressType compress_type) {
     if (compress_type == COMPRESS_TYPE_NONE) {
-        base::IOBufAsZeroCopyOutputStream wrapper(buf);
+        butil::IOBufAsZeroCopyOutputStream wrapper(buf);
         return msg.SerializeToZeroCopyStream(&wrapper);
     }
     const CompressHandler* handler = FindCompressHandler(compress_type);

src/brpc/compress.h

@@ -19,7 +19,7 @@
 #define BRPC_COMPRESS_H
 
 #include <google/protobuf/message.h>              // Message
-#include "base/iobuf.h"                           // base::IOBuf
+#include "butil/iobuf.h"                           // butil::IOBuf
 #include "brpc/options.pb.h"                     // CompressType
 
 namespace brpc {
@@ -27,11 +27,11 @@ namespace brpc {
 struct CompressHandler {
     // Compress serialized `msg' into `buf'.
     // Returns true on success, false otherwise
-    bool (*Compress)(const google::protobuf::Message& msg, base::IOBuf* buf);
+    bool (*Compress)(const google::protobuf::Message& msg, butil::IOBuf* buf);
 
     // Parse decompressed `data' as `msg'.
     // Returns true on success, false otherwise
-    bool (*Decompress)(const base::IOBuf& data, google::protobuf::Message* msg);
+    bool (*Decompress)(const butil::IOBuf& data, google::protobuf::Message* msg);
 
     // Name of the compression algorithm, must be string constant.
     const char* name;
@@ -49,14 +49,14 @@ void ListCompressHandler(std::vector<CompressHandler>* vec);
 
 // Parse decompressed `data' as `msg' using registered `compress_type'.
 // Returns true on success, false otherwise
-bool ParseFromCompressedData(const base::IOBuf& data,
+bool ParseFromCompressedData(const butil::IOBuf& data,
                              google::protobuf::Message* msg,
                              CompressType compress_type);
 
 // Compress serialized `msg' into `buf' using registered `compress_type'.
 // Returns true on success, false otherwise
 bool SerializeAsCompressedData(const google::protobuf::Message& msg,
-                               base::IOBuf* buf,
+                               butil::IOBuf* buf,
                                CompressType compress_type);
 
 } // namespace brpc

src/brpc/controller.cpp

@@ -21,9 +21,9 @@
 #include <google/protobuf/descriptor.h>
 #include <gflags/gflags.h>
 #include "bthread/bthread.h"
-#include "base/string_printf.h"
-#include "base/logging.h"
-#include "base/time.h"
+#include "butil/string_printf.h"
+#include "butil/logging.h"
+#include "butil/time.h"
 #include "bthread/bthread.h"
 #include "bthread/unstable.h"
 #include "bvar/bvar.h"
@@ -129,10 +129,10 @@ Controller::~Controller() {
 class IgnoreAllRead : public ProgressiveReader {
 public:
     // @ProgressiveReader
-    base::Status OnReadOnePart(const void* /*data*/, size_t /*length*/) {
-        return base::Status::OK();
+    butil::Status OnReadOnePart(const void* /*data*/, size_t /*length*/) {
+        return butil::Status::OK();
     }
-    void OnEndOfMessage(const base::Status&) {}
+    void OnEndOfMessage(const butil::Status&) {}
 };
 
 static IgnoreAllRead* s_ignore_all_read = NULL;
@@ -145,7 +145,7 @@ static void CreateIgnoreAllRead() { s_ignore_all_read = new IgnoreAllRead; }
 // they'll be set uniformly after this method is called.
 void Controller::DeleteStuff() {
     if (_span) {
-        Span::Submit(_span, base::cpuwide_time_us());
+        Span::Submit(_span, butil::cpuwide_time_us());
     }
     _error_text.clear();
     if (_session_local_data) {
@@ -201,8 +201,8 @@ void Controller::InternalReset(bool in_constructor) {
     _span = NULL;
     _flags = 0;
     _error_code = 0;
-    _remote_side = base::EndPoint();
-    _local_side = base::EndPoint();
+    _remote_side = butil::EndPoint();
+    _local_side = butil::EndPoint();
     _begin_time_us = 0;
     _end_time_us = 0;
     _session_local_data = NULL;
@@ -340,7 +340,7 @@ void Controller::AppendServerIdentiy() {
         _error_text.push_back('[');
         char ipbuf[64];
         int len = snprintf(ipbuf, sizeof(ipbuf), "%s:%d", 
-                           base::my_ip_cstr(), _server->listen_address().port);
+                           butil::my_ip_cstr(), _server->listen_address().port);
         unsigned char digest[MD5_DIGEST_LENGTH];
         MD5((const unsigned char*)ipbuf, len, digest);
         for (size_t i = 0; i < sizeof(digest); ++i) {
@@ -349,8 +349,8 @@ void Controller::AppendServerIdentiy() {
         }
         _error_text.push_back(']');
     } else {
-        base::string_appendf(&_error_text, "[%s:%d]",
-                             base::my_ip_cstr(), _server->listen_address().port);
+        butil::string_appendf(&_error_text, "[%s:%d]",
+                             butil::my_ip_cstr(), _server->listen_address().port);
     }
 }
 
@@ -360,7 +360,7 @@ void Controller::SetFailed(const std::string& reason) {
         _error_text.push_back(' ');
     }
     if (_current_call.nretry != 0) {
-        base::string_appendf(&_error_text, "[R%d]", _current_call.nretry);
+        butil::string_appendf(&_error_text, "[R%d]", _current_call.nretry);
     } else {
         AppendServerIdentiy();
     }
@@ -381,17 +381,17 @@ void Controller::SetFailed(int error_code, const char* reason_fmt, ...) {
         _error_text.push_back(' ');
     }
     if (_current_call.nretry != 0) {
-        base::string_appendf(&_error_text, "[R%d]", _current_call.nretry);
+        butil::string_appendf(&_error_text, "[R%d]", _current_call.nretry);
     } else {
         AppendServerIdentiy();
     }
     const size_t old_size = _error_text.size();
     if (_error_code != -1) {
-        base::string_appendf(&_error_text, "[E%d]", _error_code);
+        butil::string_appendf(&_error_text, "[E%d]", _error_code);
     }
     va_list ap;
     va_start(ap, reason_fmt);
-    base::string_vappendf(&_error_text, reason_fmt, ap);
+    butil::string_vappendf(&_error_text, reason_fmt, ap);
     va_end(ap);
     if (_span) {
         _span->set_error_code(_error_code);
@@ -408,17 +408,17 @@ void Controller::CloseConnection(const char* reason_fmt, ...) {
         _error_text.push_back(' ');
     }
     if (_current_call.nretry != 0) {
-        base::string_appendf(&_error_text, "[R%d]", _current_call.nretry);
+        butil::string_appendf(&_error_text, "[R%d]", _current_call.nretry);
     } else {
         AppendServerIdentiy();
     }
     const size_t old_size = _error_text.size();
     if (_error_code != -1) {
-        base::string_appendf(&_error_text, "[E%d]", _error_code);
+        butil::string_appendf(&_error_text, "[E%d]", _error_code);
     }
     va_list ap;
     va_start(ap, reason_fmt);
-    base::string_vappendf(&_error_text, reason_fmt, ap);
+    butil::string_vappendf(&_error_text, reason_fmt, ap);
     va_end(ap);
     if (_span) {
         _span->set_error_code(_error_code);
@@ -533,7 +533,7 @@ void Controller::OnVersionedRPCReturned(const CompletionInfo& info,
         if (timeout_ms() >= 0) {
             rc = bthread_timer_add(
                     &_timeout_id,
-                    base::microseconds_to_timespec(_abstime_us),
+                    butil::microseconds_to_timespec(_abstime_us),
                     HandleTimeout, (void*)_correlation_id.value);
         }
         if (rc != 0) {
@@ -560,7 +560,7 @@ void Controller::OnVersionedRPCReturned(const CompletionInfo& info,
         }
         ++_current_call.nretry;
         add_flag(FLAGS_BACKUP_REQUEST);
-        return IssueRPC(base::gettimeofday_us());
+        return IssueRPC(butil::gettimeofday_us());
     } else if (_retry_policy ? _retry_policy->DoRetry(this)
                : DefaultRetryPolicy()->DoRetry(this)) {
         // The error must come from _current_call because:
@@ -588,7 +588,7 @@ void Controller::OnVersionedRPCReturned(const CompletionInfo& info,
         }
         response_attachment().clear();
         
-        return IssueRPC(base::gettimeofday_us());
+        return IssueRPC(butil::gettimeofday_us());
     }
     
 END_OF_RPC:
@@ -836,7 +836,7 @@ void Controller::EndRPC(const CompletionInfo& info) {
             // Join is not signalled when the done does not Run() and the done
             // can't Run() because all backup threads are blocked by Join().
             
-            OnRPCEnd(base::gettimeofday_us());
+            OnRPCEnd(butil::gettimeofday_us());
             const bool destroy_cid_in_done = has_flag(FLAGS_DESTROY_CID_IN_DONE);
             _done->Run();
             // NOTE: Don't touch this Controller anymore, because it's likely to be
@@ -868,7 +868,7 @@ void Controller::RunDoneInBackupThread(void* arg) {
 void Controller::DoneInBackupThread() {
     // OnRPCEnd for sync RPC is called in Channel::CallMethod to count in
     // latency of the context-switch.
-    OnRPCEnd(base::gettimeofday_us());
+    OnRPCEnd(butil::gettimeofday_us());
     const CallId saved_cid = _correlation_id;
     const bool destroy_cid_in_done = has_flag(FLAGS_DESTROY_CID_IN_DONE);
     _done->Run();
@@ -879,7 +879,7 @@ void Controller::DoneInBackupThread() {
 }
 
 void Controller::SubmitSpan() {
-    const int64_t now = base::cpuwide_time_us();
+    const int64_t now = butil::cpuwide_time_us();
     _span->set_start_callback_us(now);
     if (_span->local_parent()) {
         _span->local_parent()->AsParent();
@@ -1042,7 +1042,7 @@ void Controller::IssueRPC(int64_t start_realtime_us) {
         }
     }
     // Make request
-    base::IOBuf packet;
+    butil::IOBuf packet;
     SocketMessage* user_packet = NULL;
     _pack_request(&packet, &user_packet, cid.value, _method, this,
                   _request_buf, using_auth);
@@ -1061,11 +1061,11 @@ void Controller::IssueRPC(int64_t start_realtime_us) {
     timespec* pabstime = NULL;
     if (_connect_timeout_ms > 0) {
         if (_abstime_us >= 0) {
-            connect_abstime = base::microseconds_to_timespec(
+            connect_abstime = butil::microseconds_to_timespec(
                 std::min(_connect_timeout_ms * 1000L + start_realtime_us,
                          _abstime_us));
         } else {
-            connect_abstime = base::microseconds_to_timespec(
+            connect_abstime = butil::microseconds_to_timespec(
                 _connect_timeout_ms * 1000L + start_realtime_us);
         }
         pabstime = &connect_abstime;
@@ -1088,7 +1088,7 @@ void Controller::IssueRPC(int64_t start_realtime_us) {
     }
     if (span) {
         if (_current_call.nretry == 0) {
-            span->set_sent_us(base::cpuwide_time_us());
+            span->set_sent_us(butil::cpuwide_time_us());
             span->set_request_size(packet_size);
         } else {
             span->Annotate("Requested(%lld) [%d]",
@@ -1121,16 +1121,16 @@ int Controller::HandleSocketFailed(bthread_id_t id, void* data, int error_code,
     if (error_code == ERPCTIMEDOUT) {
         cntl->SetFailed(error_code, "Reached timeout=%" PRId64 "ms @%s",
                         cntl->timeout_ms(),
-                        base::endpoint2str(cntl->remote_side()).c_str());
+                        butil::endpoint2str(cntl->remote_side()).c_str());
     } else if (error_code == EBACKUPREQUEST) {
         cntl->SetFailed(error_code, "Reached backup timeout=%" PRId64 "ms @%s",
                         cntl->backup_request_ms(),
-                        base::endpoint2str(cntl->remote_side()).c_str());
+                        butil::endpoint2str(cntl->remote_side()).c_str());
     } else if (!error_text.empty()) {
         cntl->SetFailed(error_code, "%s", error_text.c_str());
     } else {
         cntl->SetFailed(error_code, "%s @%s", berror(error_code),
-                        base::endpoint2str(cntl->remote_side()).c_str());
+                        butil::endpoint2str(cntl->remote_side()).c_str());
     }
     CompletionInfo info = { id, false };
     cntl->OnVersionedRPCReturned(info, true, saved_error);
@@ -1138,9 +1138,9 @@ int Controller::HandleSocketFailed(bthread_id_t id, void* data, int error_code,
 }
 
 CallId Controller::call_id() {
-    base::atomic<uint64_t>* target =
-        (base::atomic<uint64_t>*)&_correlation_id.value;
-    uint64_t loaded = target->load(base::memory_order_relaxed);
+    butil::atomic<uint64_t>* target =
+        (butil::atomic<uint64_t>*)&_correlation_id.value;
+    uint64_t loaded = target->load(butil::memory_order_relaxed);
     if (loaded) {
         const CallId id = { loaded };
         return id;
@@ -1150,7 +1150,7 @@ CallId Controller::call_id() {
     // The range of this id will be reset in Channel::CallMethod
     CHECK_EQ(0, bthread_id_create2(&cid, this, HandleSocketFailed));
     if (!target->compare_exchange_strong(loaded, cid.value,
-                                         base::memory_order_relaxed)) {
+                                         butil::memory_order_relaxed)) {
         bthread_id_cancel(cid);
         cid.value = loaded;
     }
@@ -1300,17 +1300,17 @@ void Controller::ReadProgressiveAttachmentBy(ProgressiveReader* r) {
     }
     if (!is_response_read_progressively()) {
         return r->OnEndOfMessage(
-            base::Status(EINVAL, "Can't read progressive attachment from a "
+            butil::Status(EINVAL, "Can't read progressive attachment from a "
                          "controller without calling "
                          "response_will_be_read_progressively() before"));
     }
     if (_rpa == NULL) {
         return r->OnEndOfMessage(
-            base::Status(EINVAL, "ReadableProgressiveAttachment is NULL"));
+            butil::Status(EINVAL, "ReadableProgressiveAttachment is NULL"));
     }
     if (has_progressive_reader()) {
         return r->OnEndOfMessage(
-            base::Status(EPERM, "%s can't be called more than once",
+            butil::Status(EPERM, "%s can't be called more than once",
                          __FUNCTION__));
     }
     add_flag(FLAGS_PROGRESSIVE_READER);
@@ -1363,7 +1363,7 @@ class DoNothingClosure : public google::protobuf::Closure {
     void Run() { }
 };
 google::protobuf::Closure* DoNothing() {
-    return base::get_leaky_singleton<DoNothingClosure>();
+    return butil::get_leaky_singleton<DoNothingClosure>();
 }
 
 } // namespace brpc

src/brpc/controller.h

@@ -21,10 +21,10 @@
 // on internal structures, use opaque pointers instead.
 
 #include <gflags/gflags.h>                          // Users often need gflags
-#include "base/intrusive_ptr.hpp"                   // base::intrusive_ptr
+#include "butil/intrusive_ptr.hpp"                   // butil::intrusive_ptr
 #include "bthread/errno.h"                          // Redefine errno
-#include "base/endpoint.h"                          // base::EndPoint
-#include "base/iobuf.h"                             // base::IOBuf
+#include "butil/endpoint.h"                          // butil::EndPoint
+#include "butil/iobuf.h"                             // butil::IOBuf
 #include "bthread/types.h"                          // bthread_id_t
 #include "brpc/options.pb.h"                   // CompressType
 #include "brpc/errno.pb.h"                     // error code
@@ -199,7 +199,7 @@ public:
 
     // User attached data or body of http request, which is wired to network
     // directly instead of being serialized into protobuf messages.
-    base::IOBuf& request_attachment() { return _request_attachment; }
+    butil::IOBuf& request_attachment() { return _request_attachment; }
 
     ConnectionType connection_type() const { return _connection_type; }
     // Get the called method. May-be NULL for non-pb services.
@@ -292,7 +292,7 @@ public:
     
     // User attached data or body of http response, which is wired to network
     // directly instead of being serialized into protobuf messages.
-    base::IOBuf& response_attachment() { return _response_attachment; }
+    butil::IOBuf& response_attachment() { return _response_attachment; }
 
     // Create a ProgressiveAttachment to write (often after RPC).
     // If `stop_style' is FORCE_STOP, the underlying socket will be failed
@@ -344,13 +344,13 @@ public:
     // Client-side: successful or last server called. Accessible from 
     // PackXXXRequest() in protocols.
     // Server-side: returns the client sending the request
-    base::EndPoint remote_side() const { return _remote_side; }
+    butil::EndPoint remote_side() const { return _remote_side; }
     
     // Client-side: the local address for talking with server, undefined until
     // this RPC succeeds (because the connection may not be established 
     // before RPC).
     // Server-side: the address that clients access.
-    base::EndPoint local_side() const { return _local_side; }
+    butil::EndPoint local_side() const { return _local_side; }
 
     // Protocol of the request sent by client or received by server.
     ProtocolType request_protocol() const { return _request_protocol; }
@@ -392,8 +392,8 @@ public:
     const HttpHeader& http_response() const
     { return _http_response != NULL ? *_http_response : DefaultHttpHeader(); }
 
-    const base::IOBuf& request_attachment() const { return _request_attachment; }
-    const base::IOBuf& response_attachment() const { return _response_attachment; }
+    const butil::IOBuf& request_attachment() const { return _request_attachment; }
+    const butil::IOBuf& response_attachment() const { return _response_attachment; }
 
     // Return true if the remote side creates a stream.
     bool has_remote_stream() { return _remote_stream_settings != NULL; }
@@ -559,14 +559,14 @@ private:
     uint32_t _flags; // all boolean fields inside Controller
     int32_t _error_code;
     std::string _error_text;
-    base::EndPoint _remote_side;
-    base::EndPoint _local_side;
+    butil::EndPoint _remote_side;
+    butil::EndPoint _local_side;
     
     void* _session_local_data;
     const Server* _server;
     bthread_id_t _oncancel_id;
     const AuthContext* _auth_context;        // Authentication result
-    base::intrusive_ptr<MongoContext> _mongo_session_data;
+    butil::intrusive_ptr<MongoContext> _mongo_session_data;
     RpcDumpMeta* _rpc_dump_meta;
 
     ProtocolType _request_protocol;
@@ -611,7 +611,7 @@ private:
     RPCSender* _sender;
     uint64_t _request_code;
     SocketId _single_server_id;
-    base::intrusive_ptr<SharedLoadBalancer> _lb;
+    butil::intrusive_ptr<SharedLoadBalancer> _lb;
 
     // for passing parameters to created bthread, don't modify it otherwhere.
     CompletionInfo _tmp_completion_info;
@@ -626,7 +626,7 @@ private:
     Protocol::PackRequest _pack_request;
     const google::protobuf::MethodDescriptor* _method;
     const Authenticator* _auth;
-    base::IOBuf _request_buf;
+    butil::IOBuf _request_buf;
     IdlNames _idl_names;
     int64_t _idl_result;
 
@@ -634,13 +634,13 @@ private:
     HttpHeader* _http_response;
 
     // Fields with large size but low access frequency 
-    base::IOBuf _request_attachment;
-    base::IOBuf _response_attachment;
+    butil::IOBuf _request_attachment;
+    butil::IOBuf _response_attachment;
 
     // Writable progressive attachment
-    base::intrusive_ptr<ProgressiveAttachment> _wpa;
+    butil::intrusive_ptr<ProgressiveAttachment> _wpa;
     // Readable progressive attachment
-    base::intrusive_ptr<ReadableProgressiveAttachment> _rpa;
+    butil::intrusive_ptr<ReadableProgressiveAttachment> _rpa;
 
     // TODO: Replace following fields with StreamCreator
     // Defined at client side

src/brpc/describable.h

@@ -18,8 +18,8 @@
 #define BRPC_DESCRIBABLE_H
 
 #include <ostream>
-#include "base/macros.h"
-#include "base/class_name.h"
+#include "butil/macros.h"
+#include "butil/class_name.h"
 
 namespace brpc {
 
@@ -37,7 +37,7 @@ class Describable {
 public:
     virtual ~Describable() {}
     virtual void Describe(std::ostream& os, const DescribeOptions&) const {
-        os << base::class_name_str(*this);
+        os << butil::class_name_str(*this);
     }
 };
 
@@ -45,7 +45,7 @@ class NonConstDescribable {
 public:
     virtual ~NonConstDescribable() {}
     virtual void Describe(std::ostream& os, const DescribeOptions&) {
-        os << base::class_name_str(*this);
+        os << butil::class_name_str(*this);
     }
 };
 

src/brpc/destroyable.h

@@ -17,7 +17,7 @@
 #ifndef BRPC_DESTROYABLE_H
 #define BRPC_DESTROYABLE_H
 
-#include "base/unique_ptr.h"           // std::unique_ptr
+#include "butil/unique_ptr.h"           // std::unique_ptr
 
 
 namespace brpc {

src/brpc/details/controller_private_accessor.h

@@ -72,12 +72,12 @@ public:
         return *this;
     }
 
-    ControllerPrivateAccessor &set_remote_side(const base::EndPoint& pt) {
+    ControllerPrivateAccessor &set_remote_side(const butil::EndPoint& pt) {
         _cntl->_remote_side = pt;
         return *this;
     }
 
-    ControllerPrivateAccessor &set_local_side(const base::EndPoint& pt) {
+    ControllerPrivateAccessor &set_local_side(const butil::EndPoint& pt) {
         _cntl->_local_side = pt;
         return *this;
     }

src/brpc/details/has_epollrdhup.cpp

@@ -17,7 +17,7 @@
 #include <sys/epoll.h>                             // epoll_create
 #include <sys/types.h>                             // socketpair
 #include <sys/socket.h>                            // ^
-#include "base/fd_guard.h"                         // fd_guard
+#include "butil/fd_guard.h"                         // fd_guard
 #include "brpc/details/has_epollrdhup.h"
 
 #ifndef EPOLLRDHUP
@@ -28,11 +28,11 @@
 namespace brpc {
 
 static unsigned int check_epollrdhup() {
-    base::fd_guard epfd(epoll_create(16));
+    butil::fd_guard epfd(epoll_create(16));
     if (epfd < 0) {
         return 0;
     }
-    base::fd_guard fds[2];
+    butil::fd_guard fds[2];
     if (socketpair(AF_UNIX, SOCK_STREAM, 0, (int*)fds) < 0) {
         return 0;
     }

src/brpc/details/hpack.cpp

@@ -17,8 +17,8 @@
 #include "brpc/details/hpack.h"
 
 #include <limits>                                       // std::numeric_limits
-#include "base/containers/bounded_queue.h"              // base::BoundedQueue
-#include "base/containers/flat_map.h"                   // base::FlatMap
+#include "butil/containers/bounded_queue.h"              // butil::BoundedQueue
+#include "butil/containers/flat_map.h"                   // butil::FlatMap
 
 #include "brpc/details/hpack-static-table.h"       // s_static_headers
 
@@ -67,9 +67,9 @@ public:
             LOG(ERROR) << "Fail to malloc space for " << num_headers << " headers";
             return -1;
         }
-        base::BoundedQueue<Header> tmp(
+        butil::BoundedQueue<Header> tmp(
                 header_queue_storage, num_headers * sizeof(Header),
-                base::OWNS_STORAGE);
+                butil::OWNS_STORAGE);
         _header_queue.swap(tmp);
         _start_index = options.start_index;
         _need_indexes = options.need_indexes;
@@ -194,15 +194,15 @@ public:
 private:
     struct HeaderHasher {
         size_t operator()(const Header& h) const {
-            return base::DefaultHasher<std::string>()(h.name)
-                ^ base::DefaultHasher<std::string>()(h.value);
+            return butil::DefaultHasher<std::string>()(h.name)
+                ^ butil::DefaultHasher<std::string>()(h.value);
         }
     };
 
     struct HeaderEqualTo {
         bool operator()(const Header& h1, const Header& h2) const {
-            return base::DefaultEqualTo<std::string>()(h1.name, h2.name)
-                && base::DefaultEqualTo<std::string>()(h1.value, h2.value);
+            return butil::DefaultEqualTo<std::string>()(h1.name, h2.name)
+                && butil::DefaultEqualTo<std::string>()(h1.value, h2.value);
         }
     };
 
@@ -211,7 +211,7 @@ private:
     uint64_t _add_times;  // Increase when adding a new entry.
     size_t _max_size;
     size_t _size;
-    base::BoundedQueue<Header> _header_queue;
+    butil::BoundedQueue<Header> _header_queue;
 
     // -----------------------  Encoder only ----------------------------
     // Indexes that map entry to the latest time it was added.
@@ -221,8 +221,8 @@ private:
     // Since the encoder just cares whether this header is in the index table
     // rather than which the index number is, only the latest entry of the same
     // header is indexed here, which is definitely the last one to be removed.
-    base::FlatMap<Header, uint64_t, HeaderHasher, HeaderEqualTo> _header_index;
-    base::FlatMap<std::string, uint64_t> _name_index;
+    butil::FlatMap<Header, uint64_t, HeaderHasher, HeaderEqualTo> _header_index;
+    butil::FlatMap<std::string, uint64_t> _name_index;
 };
 
 struct HuffmanNode {
@@ -300,7 +300,7 @@ private:
 class HuffmanEncoder {
 DISALLOW_COPY_AND_ASSIGN(HuffmanEncoder);
 public:
-    HuffmanEncoder(base::IOBufAppender* out, const HuffmanCode* table)
+    HuffmanEncoder(butil::IOBufAppender* out, const HuffmanCode* table)
         : _out(out)
         , _table(table)
         , _partial_byte(0)
@@ -347,7 +347,7 @@ public:
     uint32_t out_bytes() const { return _out_bytes; }
 
 private:
-    base::IOBufAppender* _out;
+    butil::IOBufAppender* _out;
     const HuffmanCode* _table;
     uint8_t  _partial_byte;
     uint16_t _remain_bit;
@@ -430,7 +430,7 @@ private:
 // Primitive Type Representations
 
 // Encode variant intger and return the size
-inline size_t EncodeInteger(base::IOBufAppender* out, uint8_t msb,
+inline size_t EncodeInteger(butil::IOBufAppender* out, uint8_t msb,
                             uint8_t prefix_size, uint32_t value) {
     uint8_t max_prefix_value = (1 << prefix_size) - 1;
     if (value < max_prefix_value) {
@@ -484,7 +484,7 @@ static void CreateStaticTableOnceOrDie() {
 // Assume that no header would be larger than 10MB
 static const size_t MAX_HPACK_INTEGER = 10 * 1024 * 1024ul;
 
-inline ssize_t DecodeInteger(base::IOBufBytesIterator& iter,
+inline ssize_t DecodeInteger(butil::IOBufBytesIterator& iter,
                              uint8_t prefix_size, uint32_t* value) {
     if (iter == NULL) {
         return 0; // No enough data
@@ -520,7 +520,7 @@ inline ssize_t DecodeInteger(base::IOBufBytesIterator& iter,
     return in_bytes;
 }
 
-inline size_t EncodeString(base::IOBufAppender* out, const std::string& s,
+inline size_t EncodeString(butil::IOBufAppender* out, const std::string& s,
                            bool huffman_encoding) {
     size_t out_bytes = 0;
     if (!huffman_encoding) {
@@ -546,7 +546,7 @@ inline size_t EncodeString(base::IOBufAppender* out, const std::string& s,
     return out_bytes;
 }
 
-inline ssize_t DecodeString(base::IOBufBytesIterator& iter, std::string* out) {
+inline ssize_t DecodeString(butil::IOBufBytesIterator& iter, std::string* out) {
     if (iter == NULL) {
         return 0;
     }
@@ -634,7 +634,7 @@ inline int HPacker::FindNameFromIndexTable(const std::string& name) const {
     return _encode_table->GetIndexOfName(name);
 }
 
-ssize_t HPacker::Encode(base::IOBufAppender* out, const Header& header,
+ssize_t HPacker::Encode(butil::IOBufAppender* out, const Header& header,
                         const HPackOptions& options) {
     if (options.index_policy != HPACK_NEVER_INDEX_HEADER) {
         const int index = FindHeaderFromIndexTable(header);
@@ -674,7 +674,7 @@ inline const HPacker::Header* HPacker::HeaderAt(int index) const {
 }
 
 inline ssize_t HPacker::DecodeWithKnownPrefix(
-        base::IOBufBytesIterator& iter, Header* h, uint8_t prefix_size) const {
+        butil::IOBufBytesIterator& iter, Header* h, uint8_t prefix_size) const {
     int index = 0;
     ssize_t index_bytes = DecodeInteger(iter, prefix_size, (uint32_t*)&index);
     ssize_t name_bytes = 0;
@@ -704,7 +704,7 @@ inline ssize_t HPacker::DecodeWithKnownPrefix(
     return index_bytes + name_bytes + value_bytes;
 }
 
-ssize_t HPacker::Decode(base::IOBufBytesIterator& iter, Header* h) {
+ssize_t HPacker::Decode(butil::IOBufBytesIterator& iter, Header* h) {
     if (iter == NULL) {
         return 0;
     }

src/brpc/details/hpack.h

@@ -17,8 +17,8 @@
 #ifndef  BRPC_HPACK_H
 #define  BRPC_HPACK_H
 
-#include "base/iobuf.h"                             // base::IOBuf
-#include "base/strings/string_piece.h"              // base::StringPiece
+#include "butil/iobuf.h"                             // butil::IOBuf
+#include "butil/strings/string_piece.h"              // butil::StringPiece
 
 
 namespace brpc {
@@ -99,9 +99,9 @@ public:
 
     // Encode header and append the encoded buffer to |out|
     // Returns the size of encoded buffer on success, -1 otherwise
-    ssize_t Encode(base::IOBufAppender* out, const Header& header,
+    ssize_t Encode(butil::IOBufAppender* out, const Header& header,
                    const HPackOptions& options);
-    ssize_t Encode(base::IOBufAppender* out, const Header& header)
+    ssize_t Encode(butil::IOBufAppender* out, const Header& header)
     { return Encode(out, header, HPackOptions()); }
 
     // Try to decode at most one Header from source and erase correspoding
@@ -110,24 +110,24 @@ public:
     //  * $size of decoded buffer is a header is succesfully decoded
     //  * 0 when the source is incompleted
     //  * -1 when the source is malformed
-    ssize_t Decode(base::IOBuf* source, Header* h);
+    ssize_t Decode(butil::IOBuf* source, Header* h);
 
     // Like the previous function, except that the source is from
     // IOBufBytesIterator.
-    ssize_t Decode(base::IOBufBytesIterator& source, Header* h);
+    ssize_t Decode(butil::IOBufBytesIterator& source, Header* h);
 private:
     int FindHeaderFromIndexTable(const Header& h) const;
     int FindNameFromIndexTable(const std::string& name) const;
     const Header* HeaderAt(int index) const;
     ssize_t DecodeWithKnownPrefix(
-            base::IOBufBytesIterator& iter, Header* h, uint8_t prefix_size) const;
+            butil::IOBufBytesIterator& iter, Header* h, uint8_t prefix_size) const;
 
     IndexTable* _encode_table;
     IndexTable* _decode_table;
 };
 
-inline ssize_t HPacker::Decode(base::IOBuf* source, Header* h) {
-    base::IOBufBytesIterator iter(*source);
+inline ssize_t HPacker::Decode(butil::IOBuf* source, Header* h) {
+    butil::IOBufBytesIterator iter(*source);
     const ssize_t nc = Decode(iter, h);
     if (nc > 0) {
         source->pop_front(nc);

src/brpc/details/http_message.cpp

@@ -20,11 +20,11 @@
 #include <string>                               // std::string
 #include <iostream>
 #include <gflags/gflags.h>
-#include "base/macros.h"
-#include "base/logging.h"                       // LOG
-#include "base/scoped_lock.h"
-#include "base/endpoint.h"
-#include "base/base64.h"
+#include "butil/macros.h"
+#include "butil/logging.h"                       // LOG
+#include "butil/scoped_lock.h"
+#include "butil/endpoint.h"
+#include "butil/base64.h"
 #include "bthread/bthread.h"                    // bthread_usleep
 #include "brpc/log.h"
 #include "brpc/reloadable_flags.h"
@@ -106,17 +106,17 @@ int HttpMessage::on_header_value(http_parser *parser,
         http_message->_cur_value->append(at, length);
     }
     if (FLAGS_http_verbose) {
-        base::IOBufBuilder* vs = http_message->_vmsgbuilder;
+        butil::IOBufBuilder* vs = http_message->_vmsgbuilder;
         if (vs == NULL) {
-            vs = new base::IOBufBuilder;
+            vs = new butil::IOBufBuilder;
             http_message->_vmsgbuilder = vs;
             if (parser->type == HTTP_REQUEST) {
-                *vs << "[HTTP REQUEST @" << base::my_ip() << "]\n< "
+                *vs << "[HTTP REQUEST @" << butil::my_ip() << "]\n< "
                     << HttpMethod2Str((HttpMethod)parser->method) << ' '
                     << http_message->_url << " HTTP/" << parser->http_major
                     << '.' << parser->http_minor;
             } else {
-                *vs << "[HTTP RESPONSE @" << base::my_ip() << "]\n< HTTP/"
+                *vs << "[HTTP RESPONSE @" << butil::my_ip() << "]\n< HTTP/"
                     << parser->http_major
                     << '.' << parser->http_minor << ' ' << parser->status_code
                     << ' ' << http_message->header().reason_phrase();
@@ -178,17 +178,17 @@ int HttpMessage::on_headers_complete(http_parser *parser) {
     return 0;
 }
 
-int HttpMessage::UnlockAndFlushToBodyReader(std::unique_lock<base::Mutex>& mu) {
+int HttpMessage::UnlockAndFlushToBodyReader(std::unique_lock<butil::Mutex>& mu) {
     if (_body.empty()) {
         mu.unlock();
         return 0;
     }
-    base::IOBuf body_seen = _body.movable();
+    butil::IOBuf body_seen = _body.movable();
     ProgressiveReader* r = _body_reader;
     mu.unlock();
     for (size_t i = 0; i < body_seen.backing_block_num(); ++i) {
-        base::StringPiece blk = body_seen.backing_block(i);
-        base::Status st = r->OnReadOnePart(blk.data(), blk.size());
+        butil::StringPiece blk = body_seen.backing_block(i);
+        butil::Status st = r->OnReadOnePart(blk.data(), blk.size());
         if (!st.ok()) {
             mu.lock();
             _body_reader = NULL;
@@ -239,7 +239,7 @@ int HttpMessage::OnBody(const char *at, const size_t length) {
         return 0;
     }
     // Progressive read.
-    std::unique_lock<base::Mutex> mu(_body_mutex);
+    std::unique_lock<butil::Mutex> mu(_body_mutex);
     ProgressiveReader* r = _body_reader;
     while (r == NULL) {
         // When _body is full, the sleep-waiting may block parse handler
@@ -262,7 +262,7 @@ int HttpMessage::OnBody(const char *at, const size_t length) {
     if (UnlockAndFlushToBodyReader(mu) != 0) {
         return -1;
     }
-    base::Status st = r->OnReadOnePart(at, length);
+    butil::Status st = r->OnReadOnePart(at, length);
     if (st.ok()) {
         return 0;
     }
@@ -291,7 +291,7 @@ int HttpMessage::OnMessageComplete() {
         return 0;
     }
     // Progressive read.
-    std::unique_lock<base::Mutex> mu(_body_mutex);
+    std::unique_lock<butil::Mutex> mu(_body_mutex);
     _stage = HTTP_ON_MESSAGE_COMPLELE;
     if (_body_reader != NULL) {
         // Solve the case: SetBodyReader quit at ntry=MAX_TRY with non-empty
@@ -304,7 +304,7 @@ int HttpMessage::OnMessageComplete() {
         ProgressiveReader* r = _body_reader;
         _body_reader = NULL;
         mu.unlock();
-        r->OnEndOfMessage(base::Status());
+        r->OnEndOfMessage(butil::Status());
     }
     return 0;
 }
@@ -312,11 +312,11 @@ int HttpMessage::OnMessageComplete() {
 class FailAllRead : public ProgressiveReader {
 public:
     // @ProgressiveReader
-    base::Status OnReadOnePart(const void* /*data*/, size_t /*length*/) {
-        return base::Status(-1, "Trigger by FailAllRead at %s:%d",
+    butil::Status OnReadOnePart(const void* /*data*/, size_t /*length*/) {
+        return butil::Status(-1, "Trigger by FailAllRead at %s:%d",
                             __FILE__, __LINE__);
     }
-    void OnEndOfMessage(const base::Status&) {}
+    void OnEndOfMessage(const butil::Status&) {}
 };
 
 static FailAllRead* s_fail_all_read = NULL;
@@ -326,17 +326,17 @@ static void CreateFailAllRead() { s_fail_all_read = new FailAllRead; }
 void HttpMessage::SetBodyReader(ProgressiveReader* r) {
     if (!_read_body_progressively) {
         return r->OnEndOfMessage(
-            base::Status(EPERM, "Call SetBodyReader on HttpMessage with"
+            butil::Status(EPERM, "Call SetBodyReader on HttpMessage with"
                          " read_body_progressively=false"));
     }
     const int MAX_TRY = 3;
     int ntry = 0;
     do {
-        std::unique_lock<base::Mutex> mu(_body_mutex);
+        std::unique_lock<butil::Mutex> mu(_body_mutex);
         if (_body_reader != NULL) {
             mu.unlock();
             return r->OnEndOfMessage(
-                base::Status(EPERM, "SetBodyReader is called more than once"));
+                butil::Status(EPERM, "SetBodyReader is called more than once"));
         }
         if (_body.empty()) {
             if (_stage <= HTTP_ON_BODY) {
@@ -344,7 +344,7 @@ void HttpMessage::SetBodyReader(ProgressiveReader* r) {
                 return;
             } else {  // The body is complete and successfully consumed.
                 mu.unlock();
-                return r->OnEndOfMessage(base::Status());
+                return r->OnEndOfMessage(butil::Status());
             }
         } else if (_stage <= HTTP_ON_BODY && ++ntry >= MAX_TRY) {
             // Stop making _body empty after we've tried several times.
@@ -354,11 +354,11 @@ void HttpMessage::SetBodyReader(ProgressiveReader* r) {
             _body_reader = r;
             return;
         }
-        base::IOBuf body_seen = _body.movable();
+        butil::IOBuf body_seen = _body.movable();
         mu.unlock();
         for (size_t i = 0; i < body_seen.backing_block_num(); ++i) {
-            base::StringPiece blk = body_seen.backing_block(i);
-            base::Status st = r->OnReadOnePart(blk.data(), blk.size());
+            butil::StringPiece blk = body_seen.backing_block(i);
+            butil::Status st = r->OnReadOnePart(blk.data(), blk.size());
             if (!st.ok()) {
                 r->OnEndOfMessage(st);
                 // Make OnBody() or OnMessageComplete() fail on next call to
@@ -405,7 +405,7 @@ HttpMessage::~HttpMessage() {
         // _body_reader here just means the socket is broken before completion
         // of the message.
         saved_body_reader->OnEndOfMessage(
-            base::Status(ECONNRESET, "The socket was broken"));
+            butil::Status(ECONNRESET, "The socket was broken"));
     }
 }
 
@@ -423,14 +423,14 @@ ssize_t HttpMessage::ParseFromArray(const char *data, const size_t length) {
     if (_parser.http_errno != 0) {
         // May try HTTP on other formats, failure is norm.
         RPC_VLOG << "Fail to parse http message, parser=" << _parser
-                 << ", buf=`" << base::StringPiece(data, length) << '\'';
+                 << ", buf=`" << butil::StringPiece(data, length) << '\'';
         return -1;
     } 
     _parsed_length += nprocessed;
     return nprocessed;
 }
 
-ssize_t HttpMessage::ParseFromIOBuf(const base::IOBuf &buf) {
+ssize_t HttpMessage::ParseFromIOBuf(const butil::IOBuf &buf) {
     if (Completed()) {
         if (buf.empty()) {
             return 0;
@@ -441,7 +441,7 @@ ssize_t HttpMessage::ParseFromIOBuf(const base::IOBuf &buf) {
     }
     size_t nprocessed = 0;
     for (size_t i = 0; i < buf.backing_block_num(); ++i) {
-        base::StringPiece blk = buf.backing_block(i);
+        butil::StringPiece blk = buf.backing_block(i);
         if (blk.empty()) {
             // length=0 will be treated as EOF by http_parser, must skip.
             continue;
@@ -529,11 +529,11 @@ std::ostream& operator<<(std::ostream& os, const http_parser& parser) {
 //                | "CONNECT"                ; Section 9.9
 //                | extension-method
 // extension-method = token
-void SerializeHttpRequest(base::IOBuf* request,
+void SerializeHttpRequest(butil::IOBuf* request,
                           HttpHeader* h,
-                          const base::EndPoint& remote_side,
-                          const base::IOBuf* content) {
-    base::IOBufBuilder os;
+                          const butil::EndPoint& remote_side,
+                          const butil::IOBuf* content) {
+    butil::IOBufBuilder os;
     os << HttpMethod2Str(h->method()) << ' ';
     const URI& uri = h->uri();
     uri.PrintWithoutHost(os); // host is sent by "Host" header.
@@ -588,7 +588,7 @@ void SerializeHttpRequest(base::IOBuf* request,
         // characters in this part and even if users did, most of them are
         // invalid and rejected by http_parser_parse_url().
         std::string encoded_user_info;
-        base::Base64Encode(user_info, &encoded_user_info);
+        butil::Base64Encode(user_info, &encoded_user_info);
         os << "Authorization: Basic " << encoded_user_info << BRPC_CRLF;
     }
     os << BRPC_CRLF;  // CRLF before content
@@ -606,10 +606,10 @@ void SerializeHttpRequest(base::IOBuf* request,
 //                CRLF
 //                [ message-body ]          ; Section 7.2
 // Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
-void SerializeHttpResponse(base::IOBuf* response,
+void SerializeHttpResponse(butil::IOBuf* response,
                            HttpHeader* h,
-                           base::IOBuf* content) {
-    base::IOBufBuilder os;
+                           butil::IOBuf* content) {
+    butil::IOBufBuilder os;
     os << "HTTP/" << h->major_version() << '.'
        << h->minor_version() << ' ' << h->status_code()
        << ' ' << h->reason_phrase() << BRPC_CRLF;
@@ -631,7 +631,7 @@ void SerializeHttpResponse(base::IOBuf* response,
     os << BRPC_CRLF;  // CRLF before content
     os.move_to(*response);
     if (content) {
-        response->append(base::IOBuf::Movable(*content));
+        response->append(butil::IOBuf::Movable(*content));
     }
 }
 #undef BRPC_CRLF

src/brpc/details/http_message.h

@@ -19,9 +19,9 @@
 #define BRPC_HTTP_MESSAGE_H
 
 #include <string>                           // std::string
-#include "base/macros.h"
-#include "base/iobuf.h"                     // base::IOBuf
-#include "base/scoped_lock.h"               // base::unique_lock
+#include "butil/macros.h"
+#include "butil/iobuf.h"                     // butil::IOBuf
+#include "butil/scoped_lock.h"               // butil::unique_lock
 #include "brpc/details/http_parser.h"  // http_parser
 #include "brpc/http_header.h"          // HttpHeader
 #include "brpc/progressive_reader.h"   // ProgressiveReader
@@ -47,17 +47,17 @@ public:
     explicit HttpMessage(bool read_body_progressively = false);
     ~HttpMessage();
 
-    const base::IOBuf &body() const { return _body; }
-    base::IOBuf &body() { return _body; }
+    const butil::IOBuf &body() const { return _body; }
+    butil::IOBuf &body() { return _body; }
 
     // Parse from array, length=0 is treated as EOF.
     // Returns bytes parsed, -1 on failure.
     ssize_t ParseFromArray(const char *data, const size_t length);
     
-    // Parse from base::IOBuf.
+    // Parse from butil::IOBuf.
     // Emtpy `buf' is sliently ignored, which is different from ParseFromArray.
     // Returns bytes parsed, -1 on failure.
-    ssize_t ParseFromIOBuf(const base::IOBuf &buf);
+    ssize_t ParseFromIOBuf(const butil::IOBuf &buf);
 
     bool Completed() const { return _stage == HTTP_ON_MESSAGE_COMPLELE; }
     HttpParserStage stage() const { return _stage; }
@@ -92,17 +92,17 @@ protected:
     
 private:
     DISALLOW_COPY_AND_ASSIGN(HttpMessage);
-    int UnlockAndFlushToBodyReader(std::unique_lock<base::Mutex>& locked);
+    int UnlockAndFlushToBodyReader(std::unique_lock<butil::Mutex>& locked);
 
     HttpParserStage _stage;
     std::string _url;
     HttpHeader _header;
     bool _read_body_progressively;
     // For mutual exclusion between on_body and SetBodyReader.
-    base::Mutex _body_mutex;
+    butil::Mutex _body_mutex;
     // Read body progressively
     ProgressiveReader* _body_reader;
-    base::IOBuf _body;
+    butil::IOBuf _body;
 
     // Parser related members
     struct http_parser _parser;
@@ -111,7 +111,7 @@ private:
 
 protected:
     // Only valid when -http_verbose is on
-    base::IOBufBuilder* _vmsgbuilder;
+    butil::IOBufBuilder* _vmsgbuilder;
     size_t _body_length;
 };
 
@@ -121,17 +121,17 @@ std::ostream& operator<<(std::ostream& os, const http_parser& parser);
 // header: may be modified in some cases
 // remote_side: used when "Host" is absent
 // content: could be NULL.
-void SerializeHttpRequest(base::IOBuf* request,
+void SerializeHttpRequest(butil::IOBuf* request,
                           HttpHeader* header,
-                          const base::EndPoint& remote_side,
-                          const base::IOBuf* content);
+                          const butil::EndPoint& remote_side,
+                          const butil::IOBuf* content);
 
 // Serialize a http response.
 // header: may be modified in some cases
 // content: cleared after usage. could be NULL. 
-void SerializeHttpResponse(base::IOBuf* response,
+void SerializeHttpResponse(butil::IOBuf* response,
                            HttpHeader* header,
-                           base::IOBuf* content);
+                           butil::IOBuf* content);
 
 } // namespace brpc
 

src/brpc/details/load_balancer_with_naming.h

@@ -17,7 +17,7 @@
 #ifndef BRPC_LOAD_BALANCER_WITH_NAMING_H
 #define BRPC_LOAD_BALANCER_WITH_NAMING_H
 
-#include "base/intrusive_ptr.hpp"
+#include "butil/intrusive_ptr.hpp"
 #include "brpc/load_balancer.h"
 #include "brpc/details/naming_service_thread.h"         // NamingServiceWatcher
 
@@ -40,7 +40,7 @@ public:
     void Describe(std::ostream& os, const DescribeOptions& options);
 
 private:
-    base::intrusive_ptr<NamingServiceThread> _nsthread_ptr;
+    butil::intrusive_ptr<NamingServiceThread> _nsthread_ptr;
 };
 
 } // namespace brpc