From 002c8667ef19be4b80ef7079a3a5cfb4ca85038c Mon Sep 17 00:00:00 2001 From: Jiyong Park Date: Wed, 9 Aug 2017 21:10:16 +0900 Subject: Define its own UniquePtr in gatekeeper namespace UniquePtr is deprecated and will be removed in a near future. Adding own UniquePtr.h for gatekeeper. This gatekeeper/UniquePtr.h is copied from global shared lib in Trusty. Bug: 63686260 Bug: 63866913 Test: build with BOARD_VNDK_VERSION=current and boot Change-Id: Ibe3bfd39e2381bb0c4a510abd28e1d8cc0eced72 --- Android.bp | 7 ++ gatekeeper.cpp | 2 +- include/gatekeeper/UniquePtr.h | 137 +++++++++++++++++++++++++++++++ include/gatekeeper/gatekeeper.h | 2 +- include/gatekeeper/gatekeeper_messages.h | 2 +- 5 files changed, 147 insertions(+), 3 deletions(-) create mode 100644 include/gatekeeper/UniquePtr.h diff --git a/Android.bp b/Android.bp index c739641..49a06c4 100644 --- a/Android.bp +++ b/Android.bp @@ -16,6 +16,10 @@ // GoogleGateKeeper implementation, e.g. one running in TrustZone. cc_library_shared { name: "libgatekeeper", + vendor_available: true, + vndk: { + enabled: true, + }, srcs: [ "gatekeeper_messages.cpp", "gatekeeper.cpp", @@ -25,6 +29,9 @@ cc_library_shared { "-Werror", "-g", ], + header_libs: [ + "libhardware_headers", + ], export_include_dirs: ["include"], diff --git a/gatekeeper.cpp b/gatekeeper.cpp index cfd878f..83e84fe 100644 --- a/gatekeeper.cpp +++ b/gatekeeper.cpp @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include +#include #include #include diff --git a/include/gatekeeper/UniquePtr.h b/include/gatekeeper/UniquePtr.h new file mode 100644 index 0000000..77ff99f --- /dev/null +++ b/include/gatekeeper/UniquePtr.h @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2010 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 GATEKEEPER_UNIQUE_PTR_H_included +#define GATEKEEPER_UNIQUE_PTR_H_included + +#include // For NULL. + +namespace gatekeeper { + +// Default deleter for pointer types. +template +struct DefaultDelete { + enum { type_must_be_complete = sizeof(T) }; + DefaultDelete() {} + void operator()(T* p) const { + delete p; + } +}; + +// Default deleter for array types. +template +struct DefaultDelete { + enum { type_must_be_complete = sizeof(T) }; + void operator()(T* p) const { + delete[] p; + } +}; + +// A smart pointer that deletes the given pointer on destruction. +// Equivalent to C++0x's std::unique_ptr (a combination of boost::scoped_ptr +// and boost::scoped_array). +// Named to be in keeping with Android style but also to avoid +// collision with any other implementation, until we can switch over +// to unique_ptr. +// Use thus: +// UniquePtr c(new C); +template > +class UniquePtr { +public: + // Construct a new UniquePtr, taking ownership of the given raw pointer. + explicit UniquePtr(T* ptr = NULL) : mPtr(ptr) { + } + + ~UniquePtr() { + reset(); + } + + // Accessors. + T& operator*() const { return *mPtr; } + T* operator->() const { return mPtr; } + T* get() const { return mPtr; } + + // Returns the raw pointer and hands over ownership to the caller. + // The pointer will not be deleted by UniquePtr. + T* release() __attribute__((warn_unused_result)) { + T* result = mPtr; + mPtr = NULL; + return result; + } + + // Takes ownership of the given raw pointer. + // If this smart pointer previously owned a different raw pointer, that + // raw pointer will be freed. + void reset(T* ptr = NULL) { + if (ptr != mPtr) { + D()(mPtr); + mPtr = ptr; + } + } + +private: + // The raw pointer. + T* mPtr; + + // Comparing unique pointers is probably a mistake, since they're unique. + template bool operator==(const UniquePtr& p) const; + template bool operator!=(const UniquePtr& p) const; + + // Disallow copy and assignment. + UniquePtr(const UniquePtr&); + void operator=(const UniquePtr&); +}; + +// Partial specialization for array types. Like std::unique_ptr, this removes +// operator* and operator-> but adds operator[]. +template +class UniquePtr { +public: + explicit UniquePtr(T* ptr = NULL) : mPtr(ptr) { + } + + ~UniquePtr() { + reset(); + } + + T& operator[](size_t i) const { + return mPtr[i]; + } + T* get() const { return mPtr; } + + T* release() __attribute__((warn_unused_result)) { + T* result = mPtr; + mPtr = NULL; + return result; + } + + void reset(T* ptr = NULL) { + if (ptr != mPtr) { + D()(mPtr); + mPtr = ptr; + } + } + +private: + T* mPtr; + + // Disallow copy and assignment. + UniquePtr(const UniquePtr&); + void operator=(const UniquePtr&); +}; + +} //namespace gatekeeper +#endif // GATEKEEPER_UNIQUE_PTR_H_included diff --git a/include/gatekeeper/gatekeeper.h b/include/gatekeeper/gatekeeper.h index 7e1421f..c5cd5dd 100644 --- a/include/gatekeeper/gatekeeper.h +++ b/include/gatekeeper/gatekeeper.h @@ -18,7 +18,7 @@ #define GATEKEEPER_H_ #include -#include +#include #include #include "gatekeeper_messages.h" diff --git a/include/gatekeeper/gatekeeper_messages.h b/include/gatekeeper/gatekeeper_messages.h index 1ec1e18..3cbd817 100644 --- a/include/gatekeeper/gatekeeper_messages.h +++ b/include/gatekeeper/gatekeeper_messages.h @@ -17,7 +17,7 @@ #define GATEKEEPER_MESSAGES_H_ #include -#include +#include #include "gatekeeper_utils.h" -- cgit v1.2.3