Use std::get where it's available

src/google/protobuf/compiler/cpp/cpp_unittest.cc

@@ -82,6 +82,7 @@
 
 namespace google {
 namespace protobuf {
+using internal::NewPermanentCallback;
 namespace compiler {
 namespace cpp {
 

src/google/protobuf/map.h

@@ -190,6 +190,8 @@ class LIBPROTOBUF_EXPORT MapKey {
         GOOGLE_LOG(FATAL) << "Can't get here.";
         return false;
     }
+    GOOGLE_LOG(FATAL) << "Can't get here.";
+    return false;
   }
 
   void CopyFrom(const MapKey& other) {
@@ -852,6 +854,8 @@ struct hash<google::protobuf::MapKey> {
         GOOGLE_LOG(FATAL) << "Can't get here.";
         return 0;
     }
+    GOOGLE_LOG(FATAL) << "Can't get here.";
+    return 0;
   }
   bool
   operator()(const google::protobuf::MapKey& map_key1,
@@ -875,6 +879,8 @@ struct hash<google::protobuf::MapKey> {
         GOOGLE_LOG(FATAL) << "Can't get here.";
         return true;
     }
+    GOOGLE_LOG(FATAL) << "Can't get here.";
+    return true;
   }
 };
 GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END

src/google/protobuf/stubs/callback.h

@@ -325,8 +325,6 @@ class MethodResultCallback_5_2 : public ResultCallback2<R, A1, A2> {
   typename remove_reference<P5>::type p5_;
 };
 
-}  // namespace internal
-
 // See Closure.
 inline Closure* NewCallback(void (*function)()) {
   return new internal::FunctionClosure0(function, true);
@@ -452,6 +450,8 @@ inline ResultCallback2<R, A1, A2>* NewPermanentCallback(
                                                     p2, p3, p4, p5);
 }
 
+}  // namespace internal
+
 // A function which does nothing.  Useful for creating no-op callbacks, e.g.:
 //   Closure* nothing = NewCallback(&DoNothing);
 void LIBPROTOBUF_EXPORT DoNothing();

src/google/protobuf/stubs/common.h

@@ -146,7 +146,7 @@ namespace internal {
 LIBPROTOBUF_EXPORT bool IsStructurallyValidUTF8(const char* buf, int len);
 
 inline bool IsStructurallyValidUTF8(const std::string& str) {
-  return IsStructurallyValidUTF8(str.data(), str.length());
+  return IsStructurallyValidUTF8(str.data(), static_cast<int>(str.length()));
 }
 
 // Returns initial number of bytes of structually valid UTF-8.

src/google/protobuf/stubs/common_unittest.cc

@@ -41,6 +41,8 @@
 
 namespace google {
 namespace protobuf {
+using internal::NewCallback;
+using internal::NewPermanentCallback;
 namespace {
 
 // TODO(kenton):  More tests.

src/google/protobuf/stubs/hash.h

@@ -41,9 +41,14 @@
 #define GOOGLE_PROTOBUF_HAVE_HASH_MAP 1
 #define GOOGLE_PROTOBUF_HAVE_HASH_SET 1
 
+// Android
+#if defined(__ANDROID__)
+# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP
+# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP
+
 // Use C++11 unordered_{map|set} if available.
-#if ((_LIBCPP_STD_VER >= 11) || \
-     (((__cplusplus >= 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X)) && \
+#elif ((_LIBCPP_STD_VER >= 11) || \
+      (((__cplusplus >= 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X)) && \
       (__GLIBCXX__ > 20090421)))
 # define GOOGLE_PROTOBUF_HAS_CXX11_HASH
 

src/google/protobuf/stubs/int128.cc

@@ -188,7 +188,8 @@ std::ostream& operator<<(std::ostream& o, const uint128& b) {
     if ((flags & std::ios::adjustfield) == std::ios::left) {
       rep.append(width - rep.size(), o.fill());
     } else {
-      rep.insert(0, width - rep.size(), o.fill());
+      rep.insert(static_cast<std::string::size_type>(0),
+                 width - rep.size(), o.fill());
     }
   }
 

src/google/protobuf/stubs/once_unittest.cc

@@ -43,6 +43,7 @@
 
 namespace google {
 namespace protobuf {
+using internal::NewCallback;
 namespace {
 
 class OnceInitTest : public testing::Test {
@@ -127,10 +128,11 @@ class OnceInitTest : public testing::Test {
   };
 
   TestThread* RunInitOnceInNewThread() {
-    return new TestThread(NewCallback(this, &OnceInitTest::InitOnce));
+    return new TestThread(internal::NewCallback(this, &OnceInitTest::InitOnce));
   }
   TestThread* RunInitRecursiveOnceInNewThread() {
-    return new TestThread(NewCallback(this, &OnceInitTest::InitRecursiveOnce));
+    return new TestThread(
+        internal::NewCallback(this, &OnceInitTest::InitRecursiveOnce));
   }
 
   enum State {