devel/android-tools-{adb,fastboot}-devel: update to n.p.5.3582

Changes:	https://android.googlesource.com/platform/system/core/+log/2f21b7cecda2..dfd30c4a169e/adb
Changes:	https://android.googlesource.com/platform/system/core/+log/2f21b7cecda2..dfd30c4a169e/fastboot

17 files changed, 1148 insertions, 61 deletions

diff --git a/devel/android-tools-adb-devel/Makefile b/devel/android-tools-adb-devel/Makefile
index 4706fe003561..c37905b8eeb1 100644
--- a/devel/android-tools-adb-devel/Makefile
+++ b/devel/android-tools-adb-devel/Makefile
@@ -1,9 +1,9 @@
 # $FreeBSD$
 
 # Hint: git describe --abbrev=12 --match android-n-preview-5
-DISTVERSION=	n-preview-5-126
-DISTVERSIONSUFFIX=	-g2f21b7cecda2
-PORTREVISION=	1
+DISTVERSION=	n-preview-5-3582
+DISTVERSIONSUFFIX=	-gdfd30c4a169e
+PORTREVISION=	0
 PKGNAMESUFFIX=	-devel
 
 CONFLICTS_INSTALL=	${PORTNAME}-[0-9]*
@@ -15,8 +15,11 @@ EXTRA_PATCHES=	${.CURDIR}/files/patch-*
 
 GH_MYTAG=	${DISTVERSIONPREFIX}${DISTVERSION:C/-[0-9]*$//}
 
+CPPFLAGS+=	-D_GLIBCXX_USE_C99 # XXX ports/193528
+
 OPTIONS_DEFINE=	TEST_PYTHON
 
+TEST_BUILD_DEPENDS=	googlemock>=1.6.0:devel/googlemock
 TEST_BROKEN=	logging.* tests always fail after 4e5fd111d84d
 
 TEST_PYTHON_DESC=	${TEST_DESC:S/tests/python &/}
diff --git a/devel/android-tools-adb-devel/distinfo b/devel/android-tools-adb-devel/distinfo
index 3fe918f460a9..b2a8f3366ae0 100644
--- a/devel/android-tools-adb-devel/distinfo
+++ b/devel/android-tools-adb-devel/distinfo
@@ -1,7 +1,7 @@
-TIMESTAMP = 1470755379
-SHA256 (android-platform_system_core-android-n-preview-5-126-g2f21b7cecda2_GH0.tar.gz) = 61256486af01cfefeee6779f9926ba32334b9fb1a5aacfa2cd4a682d66f01a2a
-SIZE (android-platform_system_core-android-n-preview-5-126-g2f21b7cecda2_GH0.tar.gz) = 1561372
-SHA256 (mbrubeck-android-completion-3b0fabe_GH0.tar.gz) = dc774f101acd9514baf3e7a0ac610068116f2c093b94987ba59203a39a6439dc
-SIZE (mbrubeck-android-completion-3b0fabe_GH0.tar.gz) = 5948
+TIMESTAMP = 1474960220
+SHA256 (android-platform_system_core-android-n-preview-5-3582-gdfd30c4a169e_GH0.tar.gz) = 2a4530432d51797fcc426b737d66b411d7ba4635afabe32b0c89cb581b19bc34
+SIZE (android-platform_system_core-android-n-preview-5-3582-gdfd30c4a169e_GH0.tar.gz) = 1464524
+SHA256 (mbrubeck-android-completion-c1b0656_GH0.tar.gz) = ca3311ba47a5edd56c929ac9aae57c02c2c3f1636519c5f67abb00b6e3ecd75c
+SIZE (mbrubeck-android-completion-c1b0656_GH0.tar.gz) = 5967
 SHA256 (android-platform_development-android-n-preview-5-14-g735aab1_GH0.tar.gz) = e3559503f88e0dc3f0fa3e04cd11b0666538c64a24275fc39af951b74e50f32c
 SIZE (android-platform_development-android-n-preview-5-14-g735aab1_GH0.tar.gz) = 149193336
diff --git a/devel/android-tools-adb-devel/files/Makefile b/devel/android-tools-adb-devel/files/Makefile
index c00c9a7cca46..89f027958189 100644
--- a/devel/android-tools-adb-devel/files/Makefile
+++ b/devel/android-tools-adb-devel/files/Makefile
@@ -15,6 +15,7 @@ SRCS+= adb_io.cpp
 SRCS+= adb_listeners.cpp
 SRCS+= adb_trace.cpp
 SRCS+= adb_utils.cpp
+SRCS+= bugreport.cpp
 SRCS+= commandline.cpp
 SRCS+= console.cpp
 SRCS+= diagnose_usb.cpp
@@ -23,6 +24,7 @@ SRCS+= file_sync_client.cpp
 SRCS+= line_printer.cpp
 SRCS+= services.cpp
 SRCS+= shell_service_protocol.cpp
+SRCS+= socket_spec.cpp
 SRCS+= ../adb/sockets.cpp
 SRCS+= sysdeps_unix.cpp
 SRCS+= transport.cpp
@@ -32,8 +34,10 @@ SRCS+= transport_usb.cpp
 TEST_SRCS+= adb_io_test.cpp
 TEST_SRCS+= adb_listeners_test.cpp
 TEST_SRCS+= adb_utils_test.cpp
+TEST_SRCS+= bugreport_test.cpp
 TEST_SRCS+= fdevent_test.cpp
 TEST_SRCS+= shell_service_protocol_test.cpp
+TEST_SRCS+= socket_spec_test.cpp
 TEST_SRCS+= socket_test.cpp
 TEST_SRCS+= sysdeps_test.cpp
 TEST_SRCS+= transport_test.cpp
@@ -45,7 +49,6 @@ SRCS+= main.cpp
 TEST_SRCS+= stat_test.cpp
 
 .PATH: ${EXTRADIR}
-SRCS+= get_my_path_freebsd.cpp
 SRCS+= usb_libusb.cpp
 
 .PATH: ${.CURDIR}/../base
@@ -115,6 +118,7 @@ CXXFLAGS+= ${CPPFLAGS}
 .endif
 
 TEST_CPPFLAGS+= $$(${GTEST_CONFIG} --cppflags)
+TEST_CPPFLAGS+= $$(${GMOCK_CONFIG} --cppflags)
 .for f in ${TEST_SRCS}
 CPPFLAGS.${f}+= ${TEST_CPPFLAGS}
 .endfor
@@ -124,12 +128,14 @@ LDADD+= $$(${PKG_CONFIG} libusb-1.0 --libs 2>/dev/null || echo -lusb)
 LDADD+= -lz \-lpthread
 DPADD+= ${LIBCRYPTO} ${LIBPTHREAD} ${LIBUSB} ${LIBZ}
 TEST_LDADD+= $$(${GTEST_CONFIG} --libs --ldflags)
+TEST_LDADD+= $$(${GMOCK_CONFIG} --libs --ldflags)
 
 TEST_OBJS+= ${TEST_SRCS:R:S/$/.o/}
 CLEANFILES+= ${PROG}_test ${TEST_OBJS}
 
 GIT?= git
 GTEST_CONFIG?= gtest-config
+GMOCK_CONFIG?= gmock-config
 PKG_CONFIG?= pkg-config
 
 beforeinstall:
diff --git a/devel/android-tools-adb-devel/files/get_my_path_freebsd.cpp b/devel/android-tools-adb-devel/files/get_my_path_freebsd.cpp
deleted file mode 100644
index c935adf1292a..000000000000
--- a/devel/android-tools-adb-devel/files/get_my_path_freebsd.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2009 bsdroid project
- *               Alexey Tarasov <tarasov@dodologics.com>
- *
- * Copyright (C) 2007 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#include <unistd.h>
-
-void
-get_my_path(char *exe, size_t maxLen)
-{
-    int mib[4] = {
-        CTL_KERN,
-        KERN_PROC,
-        KERN_PROC_PATHNAME,
-        getpid()
-    };
-
-    sysctl(mib, 4, exe, &maxLen, NULL, 0);
-}
diff --git a/devel/android-tools-adb-devel/files/patch-adb_adb__auth__host.cpp b/devel/android-tools-adb-devel/files/patch-adb_adb__auth__host.cpp
index 0b9d8ee7ec5d..2fb3e5335c76 100644
--- a/devel/android-tools-adb-devel/files/patch-adb_adb__auth__host.cpp
+++ b/devel/android-tools-adb-devel/files/patch-adb_adb__auth__host.cpp
@@ -1,9 +1,9 @@
 --- adb/adb_auth_host.cpp.orig	2016-06-29 23:43:15 UTC
 +++ adb/adb_auth_host.cpp
-@@ -33,7 +33,9 @@
+@@ -34,7 +34,9 @@
+ #include <android-base/stringprintf.h>
+ #include <android-base/strings.h>
  #include <crypto_utils/android_pubkey.h>
- #include <cutils/list.h>
- 
 +#if defined(OPENSSL_IS_BORINGSSL)
  #include <openssl/base64.h>
 +#endif
diff --git a/devel/android-tools-adb-devel/files/patch-adb_bugreport__test.cpp b/devel/android-tools-adb-devel/files/patch-adb_bugreport__test.cpp
new file mode 100644
index 000000000000..c201a86849dc
--- /dev/null
+++ b/devel/android-tools-adb-devel/files/patch-adb_bugreport__test.cpp
@@ -0,0 +1,18 @@
+--- adb/bugreport_test.cpp.orig	2016-09-28 18:07:09 UTC
++++ adb/bugreport_test.cpp
+@@ -40,6 +40,7 @@ using ::testing::internal::CaptureStdout
+ using ::testing::internal::GetCapturedStderr;
+ using ::testing::internal::GetCapturedStdout;
+ 
++#ifdef __linux__
+ // Empty function so tests don't need to be linked against file_sync_service.cpp, which requires
+ // SELinux and its transitive dependencies...
+ bool do_sync_pull(const std::vector<const char*>& srcs, const char* dst, bool copy_attrs,
+@@ -47,6 +48,7 @@ bool do_sync_pull(const std::vector<cons
+     ADD_FAILURE() << "do_sync_pull() should have been mocked";
+     return false;
+ }
++#endif
+ 
+ // Empty functions so tests don't need to be linked against commandline.cpp
+ DefaultStandardStreamsCallback DEFAULT_STANDARD_STREAMS_CALLBACK(nullptr, nullptr);
diff --git a/devel/android-tools-adb-devel/files/patch-adb_commandline.h b/devel/android-tools-adb-devel/files/patch-adb_commandline.h
new file mode 100644
index 000000000000..a957ad260f33
--- /dev/null
+++ b/devel/android-tools-adb-devel/files/patch-adb_commandline.h
@@ -0,0 +1,11 @@
+--- adb/commandline.h.orig	2016-09-28 18:07:09 UTC
++++ adb/commandline.h
+@@ -17,6 +17,8 @@
+ #ifndef COMMANDLINE_H
+ #define COMMANDLINE_H
+ 
++#include <stdio.h>
++
+ #include "adb.h"
+ 
+ // Callback used to handle the standard streams (stdout and stderr) sent by the
diff --git a/devel/android-tools-adb-devel/files/patch-adb_mutex b/devel/android-tools-adb-devel/files/patch-adb_mutex
new file mode 100644
index 000000000000..d3c935a3ef1c
--- /dev/null
+++ b/devel/android-tools-adb-devel/files/patch-adb_mutex
@@ -0,0 +1,995 @@
+Revert 0cd3ae1c281f until usb_libusb.cpp adopts 812f030477bc.
+
+diff --git adb/adb_utils.cpp adb/adb_utils.cpp
+index db39ef4..5a3b401 100644
+--- adb/adb_utils.cpp
++++ adb/adb_utils.cpp
+@@ -26,7 +26,6 @@
+ #include <unistd.h>
+ 
+ #include <algorithm>
+-#include <mutex>
+ #include <vector>
+ 
+ #include <android-base/logging.h>
+@@ -48,6 +47,8 @@
+ #include <pwd.h>
+ #endif
+ 
++ADB_MUTEX_DEFINE(basename_lock);
++ADB_MUTEX_DEFINE(dirname_lock);
+ 
+ #if defined(_WIN32)
+ constexpr char kNullFileName[] = "NUL";
+@@ -101,15 +102,13 @@
+ }
+ 
+ std::string adb_basename(const std::string& path) {
+-  static std::mutex& basename_lock = *new std::mutex();
+-
+   // Copy path because basename may modify the string passed in.
+   std::string result(path);
+ 
+   // Use lock because basename() may write to a process global and return a
+   // pointer to that. Note that this locking strategy only works if all other
+-  // callers to basename in the process also grab this same lock.
+-  std::lock_guard<std::mutex> lock(basename_lock);
++  // callers to dirname in the process also grab this same lock.
++  adb_mutex_lock(&basename_lock);
+ 
+   // Note that if std::string uses copy-on-write strings, &str[0] will cause
+   // the copy to be made, so there is no chance of us accidentally writing to
+@@ -120,19 +119,19 @@
+   // before leaving the lock.
+   result.assign(name);
+ 
++  adb_mutex_unlock(&basename_lock);
++
+   return result;
+ }
+ 
+ std::string adb_dirname(const std::string& path) {
+-  static std::mutex& dirname_lock = *new std::mutex();
+-
+   // Copy path because dirname may modify the string passed in.
+   std::string result(path);
+ 
+   // Use lock because dirname() may write to a process global and return a
+   // pointer to that. Note that this locking strategy only works if all other
+   // callers to dirname in the process also grab this same lock.
+-  std::lock_guard<std::mutex> lock(dirname_lock);
++  adb_mutex_lock(&dirname_lock);
+ 
+   // Note that if std::string uses copy-on-write strings, &str[0] will cause
+   // the copy to be made, so there is no chance of us accidentally writing to
+@@ -143,6 +142,8 @@
+   // before leaving the lock.
+   result.assign(parent);
+ 
++  adb_mutex_unlock(&dirname_lock);
++
+   return result;
+ }
+ 
+diff --git adb/client/main.cpp adb/client/main.cpp
+index 571c227..279bb70 100644
+--- adb/client/main.cpp
++++ adb/client/main.cpp
+@@ -170,6 +170,7 @@
+ }
+ 
+ int main(int argc, char** argv) {
++    adb_sysdeps_init();
+     adb_trace_init(argv);
+     return adb_commandline(argc - 1, const_cast<const char**>(argv + 1));
+ }
+diff --git adb/mutex_list.h adb/mutex_list.h
+deleted file mode 100644
+index 4a188ee..0000000
+--- /dev/null
++++ adb/mutex_list.h
+@@ -0,0 +1,17 @@
++/* the list of mutexes used by adb */
++/* #ifndef __MUTEX_LIST_H
++ * Do not use an include-guard. This file is included once to declare the locks
++ * and once in win32 to actually do the runtime initialization.
++ */
++#ifndef ADB_MUTEX
++#error ADB_MUTEX not defined when including this file
++#endif
++ADB_MUTEX(basename_lock)
++ADB_MUTEX(dirname_lock)
++ADB_MUTEX(transport_lock)
++#if ADB_HOST
++ADB_MUTEX(local_transports_lock)
++#endif
++ADB_MUTEX(usb_lock)
++
++#undef ADB_MUTEX
+diff --git adb/sysdeps.h adb/sysdeps.h
+index 8d99722..3ed589c 100644
+--- adb/sysdeps.h
++++ adb/sysdeps.h
+@@ -97,6 +97,27 @@
+     return c == '\\' || c == '/';
+ }
+ 
++typedef CRITICAL_SECTION          adb_mutex_t;
++
++#define  ADB_MUTEX_DEFINE(x)     adb_mutex_t   x
++
++/* declare all mutexes */
++/* For win32, adb_sysdeps_init() will do the mutex runtime initialization. */
++#define  ADB_MUTEX(x)   extern adb_mutex_t  x;
++#include "mutex_list.h"
++
++extern void  adb_sysdeps_init(void);
++
++static __inline__ void adb_mutex_lock( adb_mutex_t*  lock )
++{
++    EnterCriticalSection( lock );
++}
++
++static __inline__ void  adb_mutex_unlock( adb_mutex_t*  lock )
++{
++    LeaveCriticalSection( lock );
++}
++
+ typedef void (*adb_thread_func_t)(void* arg);
+ typedef HANDLE adb_thread_t;
+ 
+@@ -455,6 +476,27 @@
+     return c == '/';
+ }
+ 
++typedef  pthread_mutex_t          adb_mutex_t;
++
++#define  ADB_MUTEX_INITIALIZER    PTHREAD_MUTEX_INITIALIZER
++#define  adb_mutex_init           pthread_mutex_init
++#define  adb_mutex_lock           pthread_mutex_lock
++#define  adb_mutex_unlock         pthread_mutex_unlock
++#define  adb_mutex_destroy        pthread_mutex_destroy
++
++#define  ADB_MUTEX_DEFINE(m)      adb_mutex_t   m = PTHREAD_MUTEX_INITIALIZER
++
++#define  adb_cond_t               pthread_cond_t
++#define  adb_cond_init            pthread_cond_init
++#define  adb_cond_wait            pthread_cond_wait
++#define  adb_cond_broadcast       pthread_cond_broadcast
++#define  adb_cond_signal          pthread_cond_signal
++#define  adb_cond_destroy         pthread_cond_destroy
++
++/* declare all mutexes */
++#define  ADB_MUTEX(x)   extern adb_mutex_t  x;
++#include "mutex_list.h"
++
+ static __inline__ void  close_on_exec(int  fd)
+ {
+     fcntl( fd, F_SETFD, FD_CLOEXEC );
+@@ -776,6 +818,10 @@
+ #undef   mkdir
+ #define  mkdir  ___xxx_mkdir
+ 
++static __inline__ void  adb_sysdeps_init(void)
++{
++}
++
+ static __inline__ int adb_is_absolute_host_path(const char* path) {
+     return path[0] == '/';
+ }
+diff --git adb/sysdeps_test.cpp adb/sysdeps_test.cpp
+index f871675..9f77942 100644
+--- adb/sysdeps_test.cpp
++++ adb/sysdeps_test.cpp
+@@ -269,6 +269,17 @@
+     m.unlock();
+ }
+ 
++// Our implementation on Windows aborts on double lock.
++#if defined(_WIN32)
++TEST(sysdeps_mutex, mutex_reentrant_lock) {
++    std::mutex &m = *new std::mutex();
++
++    m.lock();
++    ASSERT_FALSE(m.try_lock());
++    EXPECT_DEATH(m.lock(), "non-recursive mutex locked reentrantly");
++}
++#endif
++
+ TEST(sysdeps_mutex, recursive_mutex_smoke) {
+     static std::recursive_mutex &m = *new std::recursive_mutex();
+ 
+diff --git adb/sysdeps_win32.cpp adb/sysdeps_win32.cpp
+index 5fda27b..4dd549d 100644
+--- adb/sysdeps_win32.cpp
++++ adb/sysdeps_win32.cpp
+@@ -27,7 +27,6 @@
+ 
+ #include <algorithm>
+ #include <memory>
+-#include <mutex>
+ #include <string>
+ #include <unordered_map>
+ #include <vector>
+@@ -138,7 +137,7 @@
+ #define  WIN32_FH_BASE    2048
+ #define  WIN32_MAX_FHS    2048
+ 
+-static  std::mutex&  _win32_lock = *new std::mutex();
++static adb_mutex_t   _win32_lock;
+ static  FHRec        _win32_fhs[ WIN32_MAX_FHS ];
+ static  int          _win32_fh_next;  // where to start search for free FHRec
+ 
+@@ -183,24 +182,27 @@
+ {
+     FH   f = NULL;
+ 
+-    std::lock_guard<std::mutex> lock(_win32_lock);
++    adb_mutex_lock( &_win32_lock );
+ 
+     for (int i = _win32_fh_next; i < WIN32_MAX_FHS; ++i) {
+         if (_win32_fhs[i].clazz == NULL) {
+             f = &_win32_fhs[i];
+             _win32_fh_next = i + 1;
+-            f->clazz = clazz;
+-            f->used = 1;
+-            f->eof = 0;
+-            f->name[0] = '\0';
+-            clazz->_fh_init(f);
+-            return f;
++            goto Exit;
+         }
+     }
+-
+-    D("_fh_alloc: no more free file descriptors");
+-    errno = EMFILE;  // Too many open files
+-    return nullptr;
++    D( "_fh_alloc: no more free file descriptors" );
++    errno = EMFILE;   // Too many open files
++Exit:
++    if (f) {
++        f->clazz   = clazz;
++        f->used    = 1;
++        f->eof     = 0;
++        f->name[0] = '\0';
++        clazz->_fh_init(f);
++    }
++    adb_mutex_unlock( &_win32_lock );
++    return f;
+ }
+ 
+ 
+@@ -209,7 +211,7 @@
+ {
+     // Use lock so that closing only happens once and so that _fh_alloc can't
+     // allocate a FH that we're in the middle of closing.
+-    std::lock_guard<std::mutex> lock(_win32_lock);
++    adb_mutex_lock(&_win32_lock);
+ 
+     int offset = f - _win32_fhs;
+     if (_win32_fh_next > offset) {
+@@ -223,6 +225,7 @@
+         f->used    = 0;
+         f->clazz   = NULL;
+     }
++    adb_mutex_unlock(&_win32_lock);
+     return 0;
+ }
+ 
+@@ -1231,6 +1234,17 @@
+     return true;
+ }
+ 
++static adb_mutex_t g_console_output_buffer_lock;
++
++void
++adb_sysdeps_init( void )
++{
++#define  ADB_MUTEX(x)  InitializeCriticalSection( & x );
++#include "mutex_list.h"
++    InitializeCriticalSection( &_win32_lock );
++    InitializeCriticalSection( &g_console_output_buffer_lock );
++}
++
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+@@ -2423,13 +2437,12 @@
+ // Bytes that have not yet been output to the console because they are incomplete UTF-8 sequences.
+ // Note that we use only one buffer even though stderr and stdout are logically separate streams.
+ // This matches the behavior of Linux.
++// Protected by g_console_output_buffer_lock.
++static auto& g_console_output_buffer = *new std::vector<char>();
+ 
+ // Internal helper function to write UTF-8 bytes to a console. Returns -1 on error.
+ static int _console_write_utf8(const char* const buf, const size_t buf_size, FILE* stream,
+                                HANDLE console) {
+-    static std::mutex& console_output_buffer_lock = *new std::mutex();
+-    static auto& console_output_buffer = *new std::vector<char>();
+-
+     const int saved_errno = errno;
+     std::vector<char> combined_buffer;
+ 
+@@ -2437,25 +2450,24 @@
+     const char* utf8;
+     size_t utf8_size;
+ 
+-    {
+-        std::lock_guard<std::mutex> lock(console_output_buffer_lock);
+-        if (console_output_buffer.empty()) {
+-            // If console_output_buffer doesn't have a buffered up incomplete UTF-8 sequence (the
+-            // common case with plain ASCII), parse buf directly.
+-            utf8 = buf;
+-            utf8_size = internal::ParseCompleteUTF8(buf, buf + buf_size, &console_output_buffer);
+-        } else {
+-            // If console_output_buffer has a buffered up incomplete UTF-8 sequence, move it to
+-            // combined_buffer (and effectively clear console_output_buffer) and append buf to
+-            // combined_buffer, then parse it all together.
+-            combined_buffer.swap(console_output_buffer);
+-            combined_buffer.insert(combined_buffer.end(), buf, buf + buf_size);
+-
+-            utf8 = combined_buffer.data();
+-            utf8_size = internal::ParseCompleteUTF8(utf8, utf8 + combined_buffer.size(),
+-                                                    &console_output_buffer);
+-        }
++    adb_mutex_lock(&g_console_output_buffer_lock);
++    if (g_console_output_buffer.empty()) {
++        // If g_console_output_buffer doesn't have a buffered up incomplete UTF-8 sequence (the
++        // common case with plain ASCII), parse buf directly.
++        utf8 = buf;
++        utf8_size = internal::ParseCompleteUTF8(buf, buf + buf_size, &g_console_output_buffer);
++    } else {
++        // If g_console_output_buffer has a buffered up incomplete UTF-8 sequence, move it to
++        // combined_buffer (and effectively clear g_console_output_buffer) and append buf to
++        // combined_buffer, then parse it all together.
++        combined_buffer.swap(g_console_output_buffer);
++        combined_buffer.insert(combined_buffer.end(), buf, buf + buf_size);
++
++        utf8 = combined_buffer.data();
++        utf8_size = internal::ParseCompleteUTF8(utf8, utf8 + combined_buffer.size(),
++                                                &g_console_output_buffer);
+     }
++    adb_mutex_unlock(&g_console_output_buffer_lock);
+ 
+     std::wstring utf16;
+ 
+diff --git adb/transport.cpp adb/transport.cpp
+index 3eaeb06..87712fc 100644
+--- adb/transport.cpp
++++ adb/transport.cpp
+@@ -28,7 +28,6 @@
+ 
+ #include <algorithm>
+ #include <list>
+-#include <mutex>
+ 
+ #include <android-base/logging.h>
+ #include <android-base/parsenetaddress.h>
+@@ -45,7 +44,7 @@
+ static auto& transport_list = *new std::list<atransport*>();
+ static auto& pending_list = *new std::list<atransport*>();
+ 
+-static std::mutex& transport_lock = *new std::mutex();
++ADB_MUTEX_DEFINE( transport_lock );
+ 
+ const char* const kFeatureShell2 = "shell_v2";
+ const char* const kFeatureCmd = "cmd";
+@@ -298,12 +297,13 @@
+ }
+ 
+ void kick_transport(atransport* t) {
+-    std::lock_guard<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     // As kick_transport() can be called from threads without guarantee that t is valid,
+     // check if the transport is in transport_list first.
+     if (std::find(transport_list.begin(), transport_list.end(), t) != transport_list.end()) {
+         t->Kick();
+     }
++    adb_mutex_unlock(&transport_lock);
+ }
+ 
+ static int transport_registration_send = -1;
+@@ -333,7 +333,7 @@
+     device_tracker**  pnode = &device_tracker_list;
+     device_tracker*   node  = *pnode;
+ 
+-    std::lock_guard<std::mutex> lock(transport_lock);
++    adb_mutex_lock( &transport_lock );
+     while (node) {
+         if (node == tracker) {
+             *pnode = node->next;
+@@ -342,6 +342,7 @@
+         pnode = &node->next;
+         node  = *pnode;
+     }
++    adb_mutex_unlock( &transport_lock );
+ }
+ 
+ static void
+@@ -503,10 +504,9 @@
+         fdevent_remove(&(t->transport_fde));
+         adb_close(t->fd);
+ 
+-        {
+-            std::lock_guard<std::mutex> lock(transport_lock);
+-            transport_list.remove(t);
+-        }
++        adb_mutex_lock(&transport_lock);
++        transport_list.remove(t);
++        adb_mutex_unlock(&transport_lock);
+ 
+         if (t->product)
+             free(t->product);
+@@ -555,11 +555,10 @@
+         }
+     }
+ 
+-    {
+-        std::lock_guard<std::mutex> lock(transport_lock);
+-        pending_list.remove(t);
+-        transport_list.push_front(t);
+-    }
++    adb_mutex_lock(&transport_lock);
++    pending_list.remove(t);
++    transport_list.push_front(t);
++    adb_mutex_unlock(&transport_lock);
+ 
+     update_transports();
+ }
+@@ -610,8 +609,7 @@
+ 
+ static void transport_unref(atransport* t) {
+     CHECK(t != nullptr);
+-
+-    std::lock_guard<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     CHECK_GT(t->ref_count, 0u);
+     t->ref_count--;
+     if (t->ref_count == 0) {
+@@ -621,6 +619,7 @@
+     } else {
+         D("transport: %s unref (count=%zu)", t->serial, t->ref_count);
+     }
++    adb_mutex_unlock(&transport_lock);
+ }
+ 
+ static int qual_match(const char *to_test,
+@@ -666,7 +665,7 @@
+         *error_out = "no devices found";
+     }
+ 
+-    std::unique_lock<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     for (const auto& t : transport_list) {
+         if (t->connection_state == kCsNoPerm) {
+ #if ADB_HOST
+@@ -714,7 +713,7 @@
+             }
+         }
+     }
+-    lock.unlock();
++    adb_mutex_unlock(&transport_lock);
+ 
+     // Don't return unauthorized devices; the caller can't do anything with them.
+     if (result && result->connection_state == kCsUnauthorized) {
+@@ -915,20 +914,21 @@
+ 
+ std::string list_transports(bool long_listing) {
+     std::string result;
+-
+-    std::lock_guard<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     for (const auto& t : transport_list) {
+         append_transport(t, &result, long_listing);
+     }
++    adb_mutex_unlock(&transport_lock);
+     return result;
+ }
+ 
+ /* hack for osx */
+ void close_usb_devices() {
+-    std::lock_guard<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     for (const auto& t : transport_list) {
+         t->Kick();
+     }
++    adb_mutex_unlock(&transport_lock);
+ }
+ #endif // ADB_HOST
+ 
+@@ -947,9 +947,10 @@
+         return -1;
+     }
+ 
+-    std::unique_lock<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     for (const auto& transport : pending_list) {
+         if (transport->serial && strcmp(serial, transport->serial) == 0) {
++            adb_mutex_unlock(&transport_lock);
+             VLOG(TRANSPORT) << "socket transport " << transport->serial
+                 << " is already in pending_list and fails to register";
+             delete t;
+@@ -959,6 +960,7 @@
+ 
+     for (const auto& transport : transport_list) {
+         if (transport->serial && strcmp(serial, transport->serial) == 0) {
++            adb_mutex_unlock(&transport_lock);
+             VLOG(TRANSPORT) << "socket transport " << transport->serial
+                 << " is already in transport_list and fails to register";
+             delete t;
+@@ -968,8 +970,7 @@
+ 
+     pending_list.push_front(t);
+     t->serial = strdup(serial);
+-
+-    lock.unlock();
++    adb_mutex_unlock(&transport_lock);
+ 
+     register_transport(t);
+     return 0;
+@@ -979,19 +980,20 @@
+ atransport *find_transport(const char *serial) {
+     atransport* result = nullptr;
+ 
+-    std::lock_guard<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     for (auto& t : transport_list) {
+         if (t->serial && strcmp(serial, t->serial) == 0) {
+             result = t;
+             break;
+         }
+     }
++    adb_mutex_unlock(&transport_lock);
+ 
+     return result;
+ }
+ 
+ void kick_all_tcp_devices() {
+-    std::lock_guard<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     for (auto& t : transport_list) {
+         if (t->IsTcpDevice()) {
+             // Kicking breaks the read_transport thread of this transport out of any read, then
+@@ -1001,6 +1003,7 @@
+             t->Kick();
+         }
+     }
++    adb_mutex_unlock(&transport_lock);
+ }
+ 
+ #endif
+@@ -1020,20 +1023,20 @@
+         t->devpath = strdup(devpath);
+     }
+ 
+-    {
+-        std::lock_guard<std::mutex> lock(transport_lock);
+-        pending_list.push_front(t);
+-    }
++    adb_mutex_lock(&transport_lock);
++    pending_list.push_front(t);
++    adb_mutex_unlock(&transport_lock);
+ 
+     register_transport(t);
+ }
+ 
+ // This should only be used for transports with connection_state == kCsNoPerm.
+ void unregister_usb_transport(usb_handle *usb) {
+-    std::lock_guard<std::mutex> lock(transport_lock);
++    adb_mutex_lock(&transport_lock);
+     transport_list.remove_if([usb](atransport* t) {
+         return t->usb == usb && t->connection_state == kCsNoPerm;
+     });
++    adb_mutex_unlock(&transport_lock);
+ }
+ 
+ int check_header(apacket *p, atransport *t)
+diff --git adb/transport_local.cpp adb/transport_local.cpp
+index 89e950d..f895943 100644
+--- adb/transport_local.cpp
++++ adb/transport_local.cpp
+@@ -26,7 +26,6 @@
+ #include <sys/types.h>
+ 
+ #include <condition_variable>
+-#include <mutex>
+ #include <vector>
+ 
+ #include <android-base/stringprintf.h>
+@@ -48,7 +47,7 @@
+ // connected.
+ #define ADB_LOCAL_TRANSPORT_MAX 16
+ 
+-static std::mutex& local_transports_lock = *new std::mutex();
++ADB_MUTEX_DEFINE(local_transports_lock);
+ 
+ /* we keep a list of opened transports. The atransport struct knows to which
+  * local transport it is connected. The list is used to detect when we're
+@@ -385,13 +384,14 @@
+ 
+ #if ADB_HOST
+     int  nn;
+-    std::lock_guard<std::mutex> lock(local_transports_lock);
++    adb_mutex_lock( &local_transports_lock );
+     for (nn = 0; nn < ADB_LOCAL_TRANSPORT_MAX; nn++) {
+         if (local_transports[nn] == t) {
+             local_transports[nn] = NULL;
+             break;
+         }
+     }
++    adb_mutex_unlock( &local_transports_lock );
+ #endif
+ }
+ 
+@@ -435,8 +435,9 @@
+ 
+ atransport* find_emulator_transport_by_adb_port(int adb_port)
+ {
+-    std::lock_guard<std::mutex> lock(local_transports_lock);
++    adb_mutex_lock( &local_transports_lock );
+     atransport* result = find_emulator_transport_by_adb_port_locked(adb_port);
++    adb_mutex_unlock( &local_transports_lock );
+     return result;
+ }
+ 
+@@ -454,8 +455,9 @@
+ 
+ int get_available_local_transport_index()
+ {
+-    std::lock_guard<std::mutex> lock(local_transports_lock);
++    adb_mutex_lock( &local_transports_lock );
+     int result = get_available_local_transport_index_locked();
++    adb_mutex_unlock( &local_transports_lock );
+     return result;
+ }
+ #endif
+@@ -475,20 +477,26 @@
+ 
+ #if ADB_HOST
+     if (local) {
+-        std::lock_guard<std::mutex> lock(local_transports_lock);
+-        t->SetLocalPortForEmulator(adb_port);
+-        atransport* existing_transport = find_emulator_transport_by_adb_port_locked(adb_port);
+-        int index = get_available_local_transport_index_locked();
+-        if (existing_transport != NULL) {
+-            D("local transport for port %d already registered (%p)?", adb_port, existing_transport);
+-            fail = -1;
+-        } else if (index < 0) {
+-            // Too many emulators.
+-            D("cannot register more emulators. Maximum is %d", ADB_LOCAL_TRANSPORT_MAX);
+-            fail = -1;
+-        } else {
+-            local_transports[index] = t;
+-        }
++        adb_mutex_lock( &local_transports_lock );
++        {
++            t->SetLocalPortForEmulator(adb_port);
++            atransport* existing_transport =
++                    find_emulator_transport_by_adb_port_locked(adb_port);
++            int index = get_available_local_transport_index_locked();
++            if (existing_transport != NULL) {
++                D("local transport for port %d already registered (%p)?",
++                adb_port, existing_transport);
++                fail = -1;
++            } else if (index < 0) {
++                // Too many emulators.
++                D("cannot register more emulators. Maximum is %d",
++                        ADB_LOCAL_TRANSPORT_MAX);
++                fail = -1;
++            } else {
++                local_transports[index] = t;
++            }
++       }
++       adb_mutex_unlock( &local_transports_lock );
+     }
+ #endif
+     return fail;
+diff --git adb/transport_test.cpp adb/transport_test.cpp
+index a6db07a..8b38e03 100644
+--- adb/transport_test.cpp
++++ adb/transport_test.cpp
+@@ -20,6 +20,27 @@
+ 
+ #include "adb.h"
+ 
++class TransportSetup {
++public:
++  TransportSetup() {
++#ifdef _WIN32
++    // Use extern instead of including sysdeps.h which brings in various macros
++    // that conflict with APIs used in this file.
++    extern void adb_sysdeps_init(void);
++    adb_sysdeps_init();
++#else
++    // adb_sysdeps_init() is an inline function that we cannot link against.
++#endif
++  }
++};
++
++// Static initializer will call adb_sysdeps_init() before main() to initialize
++// the transport mutex before it is used in the tests. Alternatives would be to
++// use __attribute__((constructor)) here or to use that or a static initializer
++// for adb_sysdeps_init() itself in sysdeps_win32.cpp (caveats of unclear
++// init order), or to use a test fixture whose SetUp() could do the init once.
++static TransportSetup g_TransportSetup;
++
+ TEST(transport, kick_transport) {
+   atransport t;
+   static size_t kick_count;
+diff --git adb/usb_linux_client.cpp adb/usb_linux_client.cpp
+index 0ba6b4b..1b05439 100644
+--- adb/usb_linux_client.cpp
++++ adb/usb_linux_client.cpp
+@@ -32,8 +32,6 @@
+ 
+ #include <algorithm>
+ #include <atomic>
+-#include <condition_variable>
+-#include <mutex>
+ 
+ #include <android-base/logging.h>
+ 
+@@ -56,14 +54,12 @@
+ 
+ static int dummy_fd = -1;
+ 
+-struct usb_handle {
+-    usb_handle() : kicked(false) {
+-    }
+-
+-    std::condition_variable notify;
+-    std::mutex lock;
++struct usb_handle
++{
++    adb_cond_t notify;
++    adb_mutex_t lock;
++    bool open_new_connection;
+     std::atomic<bool> kicked;
+-    bool open_new_connection = true;
+ 
+     int (*write)(usb_handle *h, const void *data, int len);
+     int (*read)(usb_handle *h, void *data, int len);
+@@ -71,12 +67,12 @@
+     void (*close)(usb_handle *h);
+ 
+     // Legacy f_adb
+-    int fd = -1;
++    int fd;
+ 
+     // FunctionFS
+-    int control = -1;
+-    int bulk_out = -1; /* "out" from the host's perspective => source for adbd */
+-    int bulk_in = -1;  /* "in" from the host's perspective => sink for adbd */
++    int control;
++    int bulk_out; /* "out" from the host's perspective => source for adbd */
++    int bulk_in;  /* "in" from the host's perspective => sink for adbd */
+ };
+ 
+ struct func_desc {
+@@ -252,12 +248,12 @@
+ 
+     while (true) {
+         // wait until the USB device needs opening
+-        std::unique_lock<std::mutex> lock(usb->lock);
++        adb_mutex_lock(&usb->lock);
+         while (!usb->open_new_connection) {
+-            usb->notify.wait(lock);
++            adb_cond_wait(&usb->notify, &usb->lock);
+         }
+         usb->open_new_connection = false;
+-        lock.unlock();
++        adb_mutex_unlock(&usb->lock);
+ 
+         D("[ usb_thread - opening device ]");
+         do {
+@@ -343,20 +339,27 @@
+     h->kicked = false;
+     adb_close(h->fd);
+     // Notify usb_adb_open_thread to open a new connection.
+-    h->lock.lock();
++    adb_mutex_lock(&h->lock);
+     h->open_new_connection = true;
+-    h->lock.unlock();
+-    h->notify.notify_one();
++    adb_cond_signal(&h->notify);
++    adb_mutex_unlock(&h->lock);
+ }
+ 
+ static void usb_adb_init()
+ {
+-    usb_handle* h = new usb_handle();
++    usb_handle* h = reinterpret_cast<usb_handle*>(calloc(1, sizeof(usb_handle)));
++    if (h == nullptr) fatal("couldn't allocate usb_handle");
+ 
+     h->write = usb_adb_write;
+     h->read = usb_adb_read;
+     h->kick = usb_adb_kick;
+     h->close = usb_adb_close;
++    h->kicked = false;
++    h->fd = -1;
++
++    h->open_new_connection = true;
++    adb_cond_init(&h->notify, 0);
++    adb_mutex_init(&h->lock, 0);
+ 
+     // Open the file /dev/android_adb_enable to trigger
+     // the enabling of the adb USB function in the kernel.
+@@ -465,12 +468,12 @@
+ 
+     while (true) {
+         // wait until the USB device needs opening
+-        std::unique_lock<std::mutex> lock(usb->lock);
++        adb_mutex_lock(&usb->lock);
+         while (!usb->open_new_connection) {
+-            usb->notify.wait(lock);
++            adb_cond_wait(&usb->notify, &usb->lock);
+         }
+         usb->open_new_connection = false;
+-        lock.unlock();
++        adb_mutex_unlock(&usb->lock);
+ 
+         while (true) {
+             if (init_functionfs(usb)) {
+@@ -554,22 +557,31 @@
+     adb_close(h->bulk_out);
+     adb_close(h->bulk_in);
+     // Notify usb_adb_open_thread to open a new connection.
+-    h->lock.lock();
++    adb_mutex_lock(&h->lock);
+     h->open_new_connection = true;
+-    h->lock.unlock();
+-    h->notify.notify_one();
++    adb_cond_signal(&h->notify);
++    adb_mutex_unlock(&h->lock);
+ }
+ 
+ static void usb_ffs_init()
+ {
+     D("[ usb_init - using FunctionFS ]");
+ 
+-    usb_handle* h = new usb_handle();
++    usb_handle* h = reinterpret_cast<usb_handle*>(calloc(1, sizeof(usb_handle)));
++    if (h == nullptr) fatal("couldn't allocate usb_handle");
+ 
+     h->write = usb_ffs_write;
+     h->read = usb_ffs_read;
+     h->kick = usb_ffs_kick;
+     h->close = usb_ffs_close;
++    h->kicked = false;
++    h->control = -1;
++    h->bulk_out = -1;
++    h->bulk_out = -1;
++
++    h->open_new_connection = true;
++    adb_cond_init(&h->notify, 0);
++    adb_mutex_init(&h->lock, 0);
+ 
+     D("[ usb_init - starting thread ]");
+     if (!adb_thread_create(usb_ffs_open_thread, h)) {
+@@ -596,7 +608,6 @@
+ {
+     return h->read(h, data, len);
+ }
+-
+ int usb_close(usb_handle *h)
+ {
+     h->close(h);
+diff --git adb/usb_windows.cpp adb/usb_windows.cpp
+index 8ecca37..4649454 100644
+--- adb/usb_windows.cpp
++++ adb/usb_windows.cpp
+@@ -19,17 +19,13 @@
+ #include "sysdeps.h"
+ 
+ #include <winsock2.h>  // winsock.h *must* be included before windows.h.
+-#include <windows.h>
+-#include <usb100.h>
+-#include <winerror.h>
+-
++#include <adb_api.h>
+ #include <errno.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+-
+-#include <mutex>
+-
+-#include <adb_api.h>
++#include <usb100.h>
++#include <windows.h>
++#include <winerror.h>
+ 
+ #include <android-base/errors.h>
+ 
+@@ -77,7 +73,7 @@
+ };
+ 
+ /// Locker for the list of opened usb handles
+-static std::mutex& usb_lock = *new std::mutex();
++ADB_MUTEX_DEFINE( usb_lock );
+ 
+ /// Checks if there is opened usb handle in handle_list for this device.
+ int known_device(const wchar_t* dev_name);
+@@ -145,8 +141,9 @@
+   int ret = 0;
+ 
+   if (NULL != dev_name) {
+-    std::lock_guard<std::mutex> lock(usb_lock);
++    adb_mutex_lock(&usb_lock);
+     ret = known_device_locked(dev_name);
++    adb_mutex_unlock(&usb_lock);
+   }
+ 
+   return ret;
+@@ -156,10 +153,11 @@
+   if (NULL == handle)
+     return 0;
+ 
+-  std::lock_guard<std::mutex> lock(usb_lock);
++  adb_mutex_lock(&usb_lock);
+ 
+   // Check if device is already in the list
+   if (known_device_locked(handle->interface_name)) {
++    adb_mutex_unlock(&usb_lock);
+     return 0;
+   }
+ 
+@@ -169,6 +167,8 @@
+   handle->prev->next = handle;
+   handle->next->prev = handle;
+ 
++  adb_mutex_unlock(&usb_lock);
++
+   return 1;
+ }
+ 
+@@ -493,8 +493,11 @@
+ void usb_kick(usb_handle* handle) {
+   D("usb_kick");
+   if (NULL != handle) {
+-    std::lock_guard<std::mutex> lock(usb_lock);
++    adb_mutex_lock(&usb_lock);
++
+     usb_kick_locked(handle);
++
++    adb_mutex_unlock(&usb_lock);
+   } else {
+     errno = EINVAL;
+   }
+@@ -505,17 +508,17 @@
+ 
+   if (NULL != handle) {
+     // Remove handle from the list
+-    {
+-      std::lock_guard<std::mutex> lock(usb_lock);
+-
+-      if ((handle->next != handle) && (handle->prev != handle)) {
+-        handle->next->prev = handle->prev;
+-        handle->prev->next = handle->next;
+-        handle->prev = handle;
+-        handle->next = handle;
+-      }
++    adb_mutex_lock(&usb_lock);
++
++    if ((handle->next != handle) && (handle->prev != handle)) {
++      handle->next->prev = handle->prev;
++      handle->prev->next = handle->next;
++      handle->prev = handle;
++      handle->next = handle;
+     }
+ 
++    adb_mutex_unlock(&usb_lock);
++
+     // Cleanup handle
+     usb_cleanup_handle(handle);
+     free(handle);
+@@ -648,8 +651,9 @@
+ static void kick_devices() {
+   // Need to acquire lock to safely walk the list which might be modified
+   // by another thread.
+-  std::lock_guard<std::mutex> lock(usb_lock);
++  adb_mutex_lock(&usb_lock);
+   for (usb_handle* usb = handle_list.next; usb != &handle_list; usb = usb->next) {
+     usb_kick_locked(usb);
+   }
++  adb_mutex_unlock(&usb_lock);
+ }
diff --git a/devel/android-tools-adb-devel/files/patch-base_file.cpp b/devel/android-tools-adb-devel/files/patch-base_file.cpp
new file mode 100644
index 000000000000..199da0b95aca
--- /dev/null
+++ b/devel/android-tools-adb-devel/files/patch-base_file.cpp
@@ -0,0 +1,40 @@
+--- base/file.cpp.orig	2016-09-28 18:07:09 UTC
++++ base/file.cpp
+@@ -18,6 +18,9 @@
+ 
+ #include <errno.h>
+ #include <fcntl.h>
++#include <limits.h> // PATH_MAX
++#include <stdio.h> // BUFSIZ
++#include <string.h> // strerror
+ #include <sys/stat.h>
+ #include <sys/types.h>
+ #include <unistd.h>
+@@ -34,6 +37,9 @@
+ #if defined(__APPLE__)
+ #include <mach-o/dyld.h>
+ #endif
++#if defined(__DragonFly__) || defined(__FreeBSD__)
++#include <sys/sysctl.h>
++#endif
+ #if defined(_WIN32)
+ #include <windows.h>
+ #endif
+@@ -231,6 +237,17 @@ std::string GetExecutablePath() {
+   if (result == 0 || result == sizeof(path) - 1) return "";
+   path[PATH_MAX - 1] = 0;
+   return path;
++#elif defined(KERN_PROC_PATHNAME)
++  char path[PATH_MAX + 1];
++  size_t path_len = sizeof(path);
++  int mib[] = {
++    CTL_KERN,
++    KERN_PROC,
++    KERN_PROC_PATHNAME,
++    getpid()
++  };
++  int rc = sysctl(mib, arraysize(mib), path, &path_len, NULL, 0);
++  return rc ? "" : path;
+ #else
+ #error unknown OS
+ #endif
diff --git a/devel/android-tools-adb/Makefile b/devel/android-tools-adb/Makefile
index c28df87d9faa..e6cd47c814fb 100644
--- a/devel/android-tools-adb/Makefile
+++ b/devel/android-tools-adb/Makefile
@@ -28,6 +28,11 @@ GH_REVISION=	88f64719d756 # generated by: make update-revision
 
 CONFLICTS_INSTALL?=	${PORTNAME}-devel-*
 
+.ifndef EXTRA_PATCHES
+EXTRA_PATCHES+=	${PATCHDIR}/extra-patch-adb_sysdeps_mutex.h
+EXTRA_PATCHES+=	${PATCHDIR}/extra-patch-base_file.cpp
+.endif
+
 USES=		compiler:c++11-lib pkgconfig ssl uidfix
 BUILD_WRKSRC=	${WRKSRC}/adb
 INSTALL_WRKSRC=	${BUILD_WRKSRC}
@@ -56,7 +61,7 @@ BASH_VARS=		LICENSE+=MIT LICENSE_COMB=multi
 
 DOCS_MAKE_ARGS_OFF=	FILES="" FILESDIR=""
 
-TEST_BUILD_DEPENDS=	googletest>=1.6.0:devel/googletest
+TEST_BUILD_DEPENDS+=	googletest>=1.6.0:devel/googletest
 TEST_ALL_TARGET=	adb_test
 
 pre-install-TEST-on: do-test
diff --git a/devel/android-tools-adb/files/patch-adb_sysdeps_mutex.h b/devel/android-tools-adb/files/extra-patch-adb_sysdeps_mutex.h
index 792d29f7f738..792d29f7f738 100644
--- a/devel/android-tools-adb/files/patch-adb_sysdeps_mutex.h
+++ b/devel/android-tools-adb/files/extra-patch-adb_sysdeps_mutex.h
diff --git a/devel/android-tools-adb/files/patch-base_file.cpp b/devel/android-tools-adb/files/extra-patch-base_file.cpp
index 754b02594d0c..754b02594d0c 100644
--- a/devel/android-tools-adb/files/patch-base_file.cpp
+++ b/devel/android-tools-adb/files/extra-patch-base_file.cpp
diff --git a/devel/android-tools-fastboot-devel/Makefile b/devel/android-tools-fastboot-devel/Makefile
index bbb12f041fe6..1b2c1ba43ec9 100644
--- a/devel/android-tools-fastboot-devel/Makefile
+++ b/devel/android-tools-fastboot-devel/Makefile
@@ -1,14 +1,14 @@
 # $FreeBSD$
 
 # Hint: git describe --abbrev=12 --match android-n-preview-5
-DISTVERSION=	n-preview-5-126
-DISTVERSIONSUFFIX=	-g2f21b7cecda2
+DISTVERSION=	n-preview-5-3582
+DISTVERSIONSUFFIX=	-gdfd30c4a169e
 PORTREVISION=	0
 PKGNAMESUFFIX=	-devel
 
 GH_MYTAG=	${DISTVERSIONPREFIX}${DISTVERSION:C/-[0-9]*$//}
-GH_TAGNAME=	${GH_MYTAG}-64-g8cd939bd7af7:extras \
-		${GH_MYTAG}-1-g1fdb726:libselinux
+GH_TAGNAME=	${GH_MYTAG}-907-g1a35848b34d6:extras \
+		${GH_MYTAG}-43-ga63b41e:libselinux
 
 CONFLICTS_INSTALL=	${PORTNAME}-[0-9]*
 
diff --git a/devel/android-tools-fastboot-devel/distinfo b/devel/android-tools-fastboot-devel/distinfo
index dcdd48c37b8e..d57fa1c069f9 100644
--- a/devel/android-tools-fastboot-devel/distinfo
+++ b/devel/android-tools-fastboot-devel/distinfo
@@ -1,11 +1,11 @@
-TIMESTAMP = 1470755379
+TIMESTAMP = 1474960220
 SHA256 (fastboot.1?id=706e754) = 2af01b064440952a82f1602691a0fecc030302722a71444946fb70d9c423d283
 SIZE (fastboot.1?id=706e754) = 5906
-SHA256 (android-platform_system_core-android-n-preview-5-126-g2f21b7cecda2_GH0.tar.gz) = 61256486af01cfefeee6779f9926ba32334b9fb1a5aacfa2cd4a682d66f01a2a
-SIZE (android-platform_system_core-android-n-preview-5-126-g2f21b7cecda2_GH0.tar.gz) = 1561372
-SHA256 (jbeich-platform_system_extras-android-n-preview-5-64-g8cd939bd7af7_GH0.tar.gz) = 8506118d4606458f098d2e7b089c3304fee935c8e50ae9bb1e1ae8caab654be7
-SIZE (jbeich-platform_system_extras-android-n-preview-5-64-g8cd939bd7af7_GH0.tar.gz) = 82049260
-SHA256 (jbeich-platform_external_libselinux-android-n-preview-5-1-g1fdb726_GH0.tar.gz) = a898cb59e585de2ec51c6c13759069e62480efe785fb808d991043a469649624
-SIZE (jbeich-platform_external_libselinux-android-n-preview-5-1-g1fdb726_GH0.tar.gz) = 63005
-SHA256 (mbrubeck-android-completion-3b0fabe_GH0.tar.gz) = dc774f101acd9514baf3e7a0ac610068116f2c093b94987ba59203a39a6439dc
-SIZE (mbrubeck-android-completion-3b0fabe_GH0.tar.gz) = 5948
+SHA256 (android-platform_system_core-android-n-preview-5-3582-gdfd30c4a169e_GH0.tar.gz) = 2a4530432d51797fcc426b737d66b411d7ba4635afabe32b0c89cb581b19bc34
+SIZE (android-platform_system_core-android-n-preview-5-3582-gdfd30c4a169e_GH0.tar.gz) = 1464524
+SHA256 (jbeich-platform_system_extras-android-n-preview-5-907-g1a35848b34d6_GH0.tar.gz) = 76c5b258753e6168796a5eeff64b44376439aa793d34786d27a9a1ba3759e174
+SIZE (jbeich-platform_system_extras-android-n-preview-5-907-g1a35848b34d6_GH0.tar.gz) = 95573256
+SHA256 (jbeich-platform_external_libselinux-android-n-preview-5-43-ga63b41e_GH0.tar.gz) = eb85e6ea45fedb123a14a2326ba3e4a9a6ef2577b2ecd258be4097a4445f8f36
+SIZE (jbeich-platform_external_libselinux-android-n-preview-5-43-ga63b41e_GH0.tar.gz) = 63141
+SHA256 (mbrubeck-android-completion-c1b0656_GH0.tar.gz) = ca3311ba47a5edd56c929ac9aae57c02c2c3f1636519c5f67abb00b6e3ecd75c
+SIZE (mbrubeck-android-completion-c1b0656_GH0.tar.gz) = 5967
diff --git a/devel/android-tools-fastboot-devel/files/patch-base_file.cpp b/devel/android-tools-fastboot-devel/files/patch-base_file.cpp
new file mode 100644
index 000000000000..199da0b95aca
--- /dev/null
+++ b/devel/android-tools-fastboot-devel/files/patch-base_file.cpp
@@ -0,0 +1,40 @@
+--- base/file.cpp.orig	2016-09-28 18:07:09 UTC
++++ base/file.cpp
+@@ -18,6 +18,9 @@
+ 
+ #include <errno.h>
+ #include <fcntl.h>
++#include <limits.h> // PATH_MAX
++#include <stdio.h> // BUFSIZ
++#include <string.h> // strerror
+ #include <sys/stat.h>
+ #include <sys/types.h>
+ #include <unistd.h>
+@@ -34,6 +37,9 @@
+ #if defined(__APPLE__)
+ #include <mach-o/dyld.h>
+ #endif
++#if defined(__DragonFly__) || defined(__FreeBSD__)
++#include <sys/sysctl.h>
++#endif
+ #if defined(_WIN32)
+ #include <windows.h>
+ #endif
+@@ -231,6 +237,17 @@ std::string GetExecutablePath() {
+   if (result == 0 || result == sizeof(path) - 1) return "";
+   path[PATH_MAX - 1] = 0;
+   return path;
++#elif defined(KERN_PROC_PATHNAME)
++  char path[PATH_MAX + 1];
++  size_t path_len = sizeof(path);
++  int mib[] = {
++    CTL_KERN,
++    KERN_PROC,
++    KERN_PROC_PATHNAME,
++    getpid()
++  };
++  int rc = sysctl(mib, arraysize(mib), path, &path_len, NULL, 0);
++  return rc ? "" : path;
+ #else
+ #error unknown OS
+ #endif
diff --git a/devel/android-tools-fastboot/Makefile b/devel/android-tools-fastboot/Makefile
index 76c53ad144b4..e211622180f6 100644
--- a/devel/android-tools-fastboot/Makefile
+++ b/devel/android-tools-fastboot/Makefile
@@ -33,6 +33,10 @@ GH_REVISION=	88f64719d756 # generated by: make update-revision
 
 CONFLICTS_INSTALL?=	${PORTNAME}-devel-*
 
+.ifndef EXTRA_PATCHES
+EXTRA_PATCHES+=	${PATCHDIR}/extra-patch-base_file.cpp
+.endif
+
 USES=		compiler:c++11-lib pkgconfig uidfix
 BUILD_WRKSRC=	${WRKSRC}/fastboot
 INSTALL_WRKSRC=	${BUILD_WRKSRC}
diff --git a/devel/android-tools-fastboot/files/patch-base_file.cpp b/devel/android-tools-fastboot/files/extra-patch-base_file.cpp
index 754b02594d0c..754b02594d0c 100644
--- a/devel/android-tools-fastboot/files/patch-base_file.cpp
+++ b/devel/android-tools-fastboot/files/extra-patch-base_file.cpp