openkylin
/
platform_system_core
mirror of https://gitee.com/openkylin/platform_system_core.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge changes I99b85f07,If28f6c8d 

* changes:
  adb: implement std::make_unique, start using it.
  base: export GetThreadId.
This commit is contained in:
Treehugger Robot 2018-03-19 20:14:33 +00:00 committed by Gerrit Code Review
parent b22451f178 31b5be69f4
commit 6156420fb7
14 changed files with 141 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
adb/adb_listeners.cpp
View File

@ -29,6 +29,7 @@
#include "socket_spec.h"
#include "sysdeps.h"
#include "sysdeps/memory.h"
#include "transport.h"
// A listener is an entity which binds to a local port and, upon receiving a connection on that
@ -203,7 +204,7 @@ InstallStatus install_listener(const std::string& local_name, const char* connec
}
}
std::unique_ptr<alistener> listener(new alistener(local_name, connect_to));
auto listener = std::make_unique<alistener>(local_name, connect_to);
int resolved = 0;
listener->fd = socket_spec_listen(listener->local_name, error, &resolved);

5
adb/client/commandline.cpp
View File

@ -61,6 +61,7 @@
#include "services.h"
#include "shell_service.h"
#include "sysdeps/chrono.h"
#include "sysdeps/memory.h"
static int install_app(int argc, const char** argv);
static int install_multiple_app(int argc, const char** argv);
@ -263,7 +264,7 @@ int read_and_dump(int fd, bool use_shell_protocol = false,
char raw_buffer[BUFSIZ];
char* buffer_ptr = raw_buffer;
if (use_shell_protocol) {
protocol.reset(new ShellProtocol(fd));
protocol = std::make_unique<ShellProtocol>(fd);
if (!protocol) {
LOG(ERROR) << "failed to allocate memory for ShellProtocol object";
return 1;
@ -630,7 +631,7 @@ static int RemoteShell(bool use_shell_protocol, const std::string& type_arg,
args->raw_stdin = raw_stdin;
args->escape_char = escape_char;
if (use_shell_protocol) {
args->protocol.reset(new ShellProtocol(args->write_fd));
args->protocol = std::make_unique<ShellProtocol>(args->write_fd);
}
if (raw_stdin) stdin_raw_init();

4
adb/daemon/shell_service.cpp
View File

@ -372,8 +372,8 @@ bool Subprocess::ForkAndExec(std::string* error) {
}
D("protocol FD = %d", protocol_sfd_.get());
input_.reset(new ShellProtocol(protocol_sfd_));
output_.reset(new ShellProtocol(protocol_sfd_));
input_ = std::make_unique<ShellProtocol>(protocol_sfd_);
output_ = std::make_unique<ShellProtocol>(protocol_sfd_);
if (!input_ || !output_) {
*error = "failed to allocate shell protocol objects";
kill(pid_, SIGKILL);

8
adb/fdevent.cpp
View File

@ -21,6 +21,7 @@
#include "fdevent.h"
#include <fcntl.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@ -36,6 +37,7 @@
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <android-base/thread_annotations.h>
#include <android-base/threads.h>
#include "adb_io.h"
#include "adb_trace.h"
@ -78,7 +80,7 @@ static auto& g_poll_node_map = *new std::unordered_map<int, PollNode>();
static auto& g_pending_list = *new std::list<fdevent*>();
static std::atomic<bool> terminate_loop(false);
static bool main_thread_valid;
static unsigned long main_thread_id;
static uint64_t main_thread_id;
static auto& run_queue_notify_fd = *new unique_fd();
static auto& run_queue_mutex = *new std::mutex();
@ -86,13 +88,13 @@ static auto& run_queue GUARDED_BY(run_queue_mutex) = *new std::deque<std::functi
void check_main_thread() {
if (main_thread_valid) {
CHECK_EQ(main_thread_id, adb_thread_id());
CHECK_EQ(main_thread_id, android::base::GetThreadId());
}
}
void set_main_thread() {
main_thread_valid = true;
main_thread_id = adb_thread_id();
main_thread_id = android::base::GetThreadId();
}
static std::string dump_fde(const fdevent* fde) {

2
adb/fdevent_test.cpp
View File

@ -99,7 +99,7 @@ static void FdEventThreadFunc(ThreadArg* arg) {
std::vector<std::unique_ptr<FdHandler>> fd_handlers;
for (size_t i = 0; i < read_fds.size(); ++i) {
fd_handlers.push_back(std::unique_ptr<FdHandler>(new FdHandler(read_fds[i], write_fds[i])));
fd_handlers.push_back(std::make_unique<FdHandler>(read_fds[i], write_fds[i]));
}
fdevent_loop();

10
adb/sysdeps.h
View File

@ -92,11 +92,6 @@ static __inline__ int adb_thread_setname(const std::string& name) {
return 0;
}
static __inline__ unsigned long adb_thread_id()
{
return GetCurrentThreadId();
}
static __inline__ void close_on_exec(int fd)
{
/* nothing really */
@ -625,11 +620,6 @@ static __inline__ int adb_is_absolute_host_path(const char* path) {
return path[0] == '/';
}
static __inline__ unsigned long adb_thread_id()
{
return (unsigned long)gettid();
}
#endif /* !_WIN32 */
static inline void disable_tcp_nagle(int fd) {

36
adb/sysdeps/memory.h Normal file
View File

@ -0,0 +1,36 @@
#pragma once
/*
* Copyright (C) 2018 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 <memory>
#include <type_traits>
#if defined(_WIN32)
// We don't have C++14 on Windows yet.
// Reimplement std::make_unique ourselves until we do.
namespace std {
template <typename T, typename... Args>
typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type make_unique(
Args&&... args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
} // namespace std
#endif

4
adb/transport.cpp
View File

@ -17,6 +17,8 @@
#define TRACE_TAG TRANSPORT
#include "sysdeps.h"
#include "sysdeps/memory.h"
#include "transport.h"
#include <ctype.h>
@ -79,7 +81,7 @@ void BlockingConnectionAdapter::Start() {
read_thread_ = std::thread([this]() {
LOG(INFO) << this->transport_name_ << ": read thread spawning";
while (true) {
std::unique_ptr<apacket> packet(new apacket());
auto packet = std::make_unique<apacket>();
if (!underlying_->Read(packet.get())) {
PLOG(INFO) << this->transport_name_ << ": read failed";
break;

10
adb/transport_local.cpp
View File

@ -45,6 +45,7 @@
#include "adb_unique_fd.h"
#include "adb_utils.h"
#include "sysdeps/chrono.h"
#include "sysdeps/memory.h"
#if ADB_HOST
@ -450,9 +451,8 @@ int init_socket_transport(atransport* t, int s, int adb_port, int local) {
#if ADB_HOST
// Emulator connection.
if (local) {
std::unique_ptr<BlockingConnection> emulator_connection(
new EmulatorConnection(std::move(fd), adb_port));
t->connection.reset(new BlockingConnectionAdapter(std::move(emulator_connection)));
auto emulator_connection = std::make_unique<EmulatorConnection>(std::move(fd), adb_port);
t->connection = std::make_unique<BlockingConnectionAdapter>(std::move(emulator_connection));
std::lock_guard<std::mutex> lock(local_transports_lock);
atransport* existing_transport = find_emulator_transport_by_adb_port_locked(adb_port);
if (existing_transport != NULL) {
@ -471,7 +471,7 @@ int init_socket_transport(atransport* t, int s, int adb_port, int local) {
#endif
// Regular tcp connection.
std::unique_ptr<BlockingConnection> fd_connection(new FdConnection(std::move(fd)));
t->connection.reset(new BlockingConnectionAdapter(std::move(fd_connection)));
auto fd_connection = std::make_unique<FdConnection>(std::move(fd));
t->connection = std::make_unique<BlockingConnectionAdapter>(std::move(fd_connection));
return fail;
}

5
adb/transport_usb.cpp
View File

@ -17,6 +17,7 @@
#define TRACE_TAG TRANSPORT
#include "sysdeps.h"
#include "sysdeps/memory.h"
#include "transport.h"
#include <stdio.h>
@ -174,8 +175,8 @@ void UsbConnection::Close() {
void init_usb_transport(atransport* t, usb_handle* h) {
D("transport: usb");
std::unique_ptr<BlockingConnection> connection(new UsbConnection(h));
t->connection.reset(new BlockingConnectionAdapter(std::move(connection)));
auto connection = std::make_unique<UsbConnection>(h);
t->connection = std::make_unique<BlockingConnectionAdapter>(std::move(connection));
t->type = kTransportUsb;
}

1
base/Android.bp
View File

@ -50,6 +50,7 @@ cc_defaults {
"quick_exit.cpp",
"stringprintf.cpp",
"strings.cpp",
"threads.cpp",
"test_utils.cpp",
],

28
base/include/android-base/threads.h Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright (C) 2018 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.
*/
#ifndef ANDROID_BASE_THREADS_H
#define ANDROID_BASE_THREADS_H
#include <stdint.h>
namespace android {
namespace base {
uint64_t GetThreadId();
}
} // namespace android
#endif

41
base/logging.cpp
View File

@ -21,6 +21,7 @@
#include "android-base/logging.h"
#include <fcntl.h>
#include <inttypes.h>
#include <libgen.h>
#include <time.h>
@ -54,41 +55,7 @@
#include <android-base/macros.h>
#include <android-base/strings.h>
// For gettid.
#if defined(__APPLE__)
#include "AvailabilityMacros.h" // For MAC_OS_X_VERSION_MAX_ALLOWED
#include <stdint.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <unistd.h>
#elif defined(__linux__) && !defined(__ANDROID__)
#include <syscall.h>
#include <unistd.h>
#elif defined(_WIN32)
#include <windows.h>
#endif
#if defined(_WIN32)
typedef uint32_t thread_id;
#else
typedef pid_t thread_id;
#endif
static thread_id GetThreadId() {
#if defined(__BIONIC__)
return gettid();
#elif defined(__APPLE__)
uint64_t tid;
pthread_threadid_np(NULL, &tid);
return tid;
#elif defined(__linux__)
return syscall(__NR_gettid);
#elif defined(_WIN32)
return GetCurrentThreadId();
#endif
}
#include <android-base/threads.h>
namespace {
#if defined(__GLIBC__)
@ -223,8 +190,8 @@ void StderrLogger(LogId, LogSeverity severity, const char* tag, const char* file
static_assert(arraysize(log_characters) - 1 == FATAL + 1,
"Mismatch in size of log_characters and values in LogSeverity");
char severity_char = log_characters[severity];
fprintf(stderr, "%s %c %s %5d %5d %s:%u] %s\n", tag ? tag : "nullptr", severity_char, timestamp,
getpid(), GetThreadId(), file, line, message);
fprintf(stderr, "%s %c %s %5d %5" PRIu64 " %s:%u] %s\n", tag ? tag : "nullptr", severity_char,
timestamp, getpid(), GetThreadId(), file, line, message);
}
void DefaultAborter(const char* abort_message) {

48
base/threads.cpp Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (C) 2018 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 <android-base/threads.h>
#include <stdint.h>
#include <unistd.h>
#if defined(__APPLE__)
#include <pthread.h>
#elif defined(__linux__) && !defined(__ANDROID__)
#include <syscall.h>
#elif defined(_WIN32)
#include <windows.h>
#endif
namespace android {
namespace base {
uint64_t GetThreadId() {
#if defined(__BIONIC__)
return gettid();
#elif defined(__APPLE__)
uint64_t tid;
pthread_threadid_np(NULL, &tid);
return tid;
#elif defined(__linux__)
return syscall(__NR_gettid);
#elif defined(_WIN32)
return GetCurrentThreadId();
#endif
}
} // namespace base
} // namespace android