1 files changed, 0 insertions, 283 deletions
diff --git a/runtimes/nn/depend/libhidl/base/HidlSupport.cpp b/runtimes/nn/depend/libhidl/base/HidlSupport.cpp
deleted file mode 100644
index 7481c74cc..000000000
--- a/runtimes/nn/depend/libhidl/base/HidlSupport.cpp
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-#define LOG_TAG "HidlSupport"
-
-#include <hidl/HidlSupport.h>
-#include "Logging.h"
-
-#include <unordered_map>
-
-#if 0 // REF-ANN
-#include <android-base/parseint.h>
-#endif
-
-namespace android {
-namespace hardware {
-
-#if 0 // REF-ANN
-namespace details {
-bool debuggable() {
-#ifdef LIBHIDL_TARGET_DEBUGGABLE
-    return true;
-#else
-    return false;
-#endif
-}
-}  // namespace details
-
-hidl_handle::hidl_handle() {
-    mHandle = nullptr;
-    mOwnsHandle = false;
-}
-
-hidl_handle::~hidl_handle() {
-    freeHandle();
-}
-
-hidl_handle::hidl_handle(const native_handle_t *handle) {
-    mHandle = handle;
-    mOwnsHandle = false;
-}
-
-// copy constructor.
-hidl_handle::hidl_handle(const hidl_handle &other) {
-    mOwnsHandle = false;
-    *this = other;
-}
-
-// move constructor.
-hidl_handle::hidl_handle(hidl_handle &&other) noexcept {
-    mOwnsHandle = false;
-    *this = std::move(other);
-}
-
-// assignment operators
-hidl_handle &hidl_handle::operator=(const hidl_handle &other) {
-    if (this == &other) {
-        return *this;
-    }
-    freeHandle();
-    if (other.mHandle != nullptr) {
-        mHandle = native_handle_clone(other.mHandle);
-        if (mHandle == nullptr) {
-            PLOG(FATAL) << "Failed to clone native_handle in hidl_handle";
-        }
-        mOwnsHandle = true;
-    } else {
-        mHandle = nullptr;
-        mOwnsHandle = false;
-    }
-    return *this;
-}
-
-hidl_handle &hidl_handle::operator=(const native_handle_t *native_handle) {
-    freeHandle();
-    mHandle = native_handle;
-    mOwnsHandle = false;
-    return *this;
-}
-
-hidl_handle &hidl_handle::operator=(hidl_handle &&other) noexcept {
-    if (this != &other) {
-        freeHandle();
-        mHandle = other.mHandle;
-        mOwnsHandle = other.mOwnsHandle;
-        other.mHandle = nullptr;
-        other.mOwnsHandle = false;
-    }
-    return *this;
-}
-
-void hidl_handle::setTo(native_handle_t* handle, bool shouldOwn) {
-    freeHandle();
-    mHandle = handle;
-    mOwnsHandle = shouldOwn;
-}
-
-const native_handle_t* hidl_handle::operator->() const {
-    return mHandle;
-}
-
-// implicit conversion to const native_handle_t*
-hidl_handle::operator const native_handle_t *() const {
-    return mHandle;
-}
-
-// explicit conversion
-const native_handle_t *hidl_handle::getNativeHandle() const {
-    return mHandle;
-}
-
-void hidl_handle::freeHandle() {
-    if (mOwnsHandle && mHandle != nullptr) {
-        // This can only be true if:
-        // 1. Somebody called setTo() with shouldOwn=true, so we know the handle
-        //    wasn't const to begin with.
-        // 2. Copy/assignment from another hidl_handle, in which case we have
-        //    cloned the handle.
-        // 3. Move constructor from another hidl_handle, in which case the original
-        //    hidl_handle must have been non-const as well.
-        native_handle_t *handle = const_cast<native_handle_t*>(
-                static_cast<const native_handle_t*>(mHandle));
-        native_handle_close(handle);
-        native_handle_delete(handle);
-        mHandle = nullptr;
-    }
-}
-#endif
-
-static const char *const kEmptyString = "";
-
-hidl_string::hidl_string()
-    : mBuffer(kEmptyString),
-      mSize(0),
-      mOwnsBuffer(false) {
-}
-
-hidl_string::~hidl_string() {
-    clear();
-}
-
-hidl_string::hidl_string(const char *s) : hidl_string() {
-    if (s == nullptr) {
-        return;
-    }
-
-    copyFrom(s, strlen(s));
-}
-
-hidl_string::hidl_string(const char *s, size_t length) : hidl_string() {
-    copyFrom(s, length);
-}
-
-hidl_string::hidl_string(const hidl_string &other): hidl_string() {
-    copyFrom(other.c_str(), other.size());
-}
-
-hidl_string::hidl_string(const std::string &s) : hidl_string() {
-    copyFrom(s.c_str(), s.size());
-}
-
-hidl_string::hidl_string(hidl_string &&other) noexcept : hidl_string() {
-    moveFrom(std::forward<hidl_string>(other));
-}
-
-hidl_string &hidl_string::operator=(hidl_string &&other) noexcept {
-    if (this != &other) {
-        clear();
-        moveFrom(std::forward<hidl_string>(other));
-    }
-    return *this;
-}
-
-hidl_string &hidl_string::operator=(const hidl_string &other) {
-    if (this != &other) {
-        clear();
-        copyFrom(other.c_str(), other.size());
-    }
-
-    return *this;
-}
-
-hidl_string &hidl_string::operator=(const char *s) {
-    clear();
-
-    if (s == nullptr) {
-        return *this;
-    }
-
-    copyFrom(s, strlen(s));
-    return *this;
-}
-
-hidl_string &hidl_string::operator=(const std::string &s) {
-    clear();
-    copyFrom(s.c_str(), s.size());
-    return *this;
-}
-
-hidl_string::operator std::string() const {
-    return std::string(mBuffer, mSize);
-}
-
-std::ostream& operator<<(std::ostream& os, const hidl_string& str) {
-    os << str.c_str();
-    return os;
-}
-
-void hidl_string::copyFrom(const char *data, size_t size) {
-    // assume my resources are freed.
-
-    if (size > UINT32_MAX) {
-        LOG(FATAL) << "string size can't exceed 2^32 bytes: " << size;
-    }
-    char *buf = (char *)malloc(size + 1);
-    memcpy(buf, data, size);
-    buf[size] = '\0';
-    mBuffer = buf;
-
-    mSize = static_cast<uint32_t>(size);
-    mOwnsBuffer = true;
-}
-
-void hidl_string::moveFrom(hidl_string &&other) {
-    // assume my resources are freed.
-
-    mBuffer = std::move(other.mBuffer);
-    mSize = other.mSize;
-    mOwnsBuffer = other.mOwnsBuffer;
-
-    other.mOwnsBuffer = false;
-    other.clear();
-}
-
-void hidl_string::clear() {
-    if (mOwnsBuffer && (mBuffer != kEmptyString)) {
-        free(const_cast<char *>(static_cast<const char *>(mBuffer)));
-    }
-
-    mBuffer = kEmptyString;
-    mSize = 0;
-    mOwnsBuffer = false;
-}
-
-void hidl_string::setToExternal(const char *data, size_t size) {
-    if (size > UINT32_MAX) {
-        LOG(FATAL) << "string size can't exceed 2^32 bytes: " << size;
-    }
-    clear();
-
-    mBuffer = data;
-    mSize = static_cast<uint32_t>(size);
-    mOwnsBuffer = false;
-}
-
-const char *hidl_string::c_str() const {
-    return mBuffer;
-}
-
-size_t hidl_string::size() const {
-    return mSize;
-}
-
-bool hidl_string::empty() const {
-    return mSize == 0;
-}
-
-}  // namespace hardware
-}  // namespace android
-
-