Merge "Remove unused code in gd/common" into main (d4951e2e) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/common/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -30,7 +30,6 @@ filegroup {
		"metric_id_manager_unittest.cc",
		"multi_priority_queue_test.cc",
		"numbers_test.cc",
		"observer_registry_test.cc",
		"strings_test.cc",
		"sync_map_count_test.cc",
		],

system/gd/common/callback_list.h

deleted100644 → 0

+0 −85

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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.
		*/

		#pragma once

		#include <utility>

		#include "base/callback_list.h"
		#include "os/handler.h"

		/* This file contains CallbackList implementation that will execute callback on provided Handler thread

		Example usage inside your class:

		private:
		common::CallbackList<void(int)> callbacks_list_;
		public:
		std::unique_ptr<common::CallbackList<void(int)>::Subscription> RegisterCallback(
		const base::RepeatingCallback<void(int)>& cb, os::Handler* handler) {
		return callbacks_list_.Add({cb, handler});
		}

		void NotifyAllCallbacks(int value) {
		callbacks_list_.Notify(value);
		}
		*/

		namespace bluetooth {
		namespace common {

		namespace {
		template <typename CallbackType>
		struct CallbackWithHandler {
		CallbackWithHandler(base::RepeatingCallback<CallbackType> callback, os::Handler* handler)
		: callback(callback), handler(handler) {}

		bool is_null() const {
		return callback.is_null();
		}

		void Reset() {
		callback.Reset();
		}

		base::RepeatingCallback<CallbackType> callback;
		os::Handler* handler;
		};

		} // namespace

		template <typename Sig>
		class CallbackList;
		template <typename... Args>
		class CallbackList<void(Args...)> : public base::internal::CallbackListBase<CallbackWithHandler<void(Args...)>> {
		public:
		using CallbackType = CallbackWithHandler<void(Args...)>;
		CallbackList() = default;
		CallbackList(const CallbackList&) = delete;
		CallbackList& operator=(const CallbackList&) = delete;

		template <typename... RunArgs>
		void Notify(RunArgs&&... args) {
		auto it = this->GetIterator();
		CallbackType* cb;
		while ((cb = it.GetNext()) != nullptr) {
		cb->handler->Post(base::Bind(cb->callback, args...));
		}
		}
		};

		} // namespace common
		} // namespace bluetooth

system/gd/common/observer_registry.h

deleted100644 → 0

+0 −75

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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.
		*/

		#pragma once

		#include <array>

		#include "common/bind.h"
		#include "common/callback.h"
		#include "os/log.h"

		namespace bluetooth {
		namespace common {

		// Tracks an observer registration on client (observer) code. Register() returns a wrapped callback object which can
		// be passed to server's register API. Unregister() invalidates the wrapped callback so all callbacks that are posted
		// to the client handler after the client called Unregister() call and before the server processed the Unregister()
		// call on its handler, are dropped.
		// Note: Register() invalidates the previous registration.
		class SingleObserverRegistry {
		public:
		template <typename R, typename... T>
		decltype(auto) Register(Callback<R(T...)> callback) {
		session_++;
		return Bind(&SingleObserverRegistry::callback_wrapper<R, T...>, Unretained(this), session_, callback);
		}

		void Unregister() {
		session_++;
		}

		private:
		template <typename R, typename... T>
		void callback_wrapper(int session, Callback<R(T...)> callback, T... t) {
		if (session == session_) {
		callback.Run(std::forward<T>(t)...);
		}
		}

		uint8_t session_ = 0;
		};

		// Tracks observer registration for multiple event type. Each event type is represented as an integer in [0, Capacity).
		template <int Capacity = 10>
		class MultipleObserverRegistry {
		public:
		template <typename R, typename... T>
		decltype(auto) Register(int event_type, Callback<R(T...)> callback) {
		ASSERT(event_type < Capacity);
		return registry_[event_type].Register(callback);
		}

		void Unregister(int event_type) {
		ASSERT(event_type < Capacity);
		registry_[event_type].Unregister();
		}

		std::array<SingleObserverRegistry, Capacity> registry_;
		};

		} // namespace common
		} // namespace bluetooth

system/gd/common/observer_registry_test.cc

deleted100644 → 0

+0 −120

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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 "common/observer_registry.h"

		#include "common/bind.h"
		#include "gtest/gtest.h"

		namespace bluetooth {
		namespace common {

		class SingleObserverRegistryTest : public ::testing::Test {
		protected:
		void SetUp() override {
		registry_ = new SingleObserverRegistry;
		}

		void TearDown() override {
		delete registry_;
		}

		SingleObserverRegistry* registry_;
		};

		void Increment(int* count) {
		(*count)++;
		}

		void IncrementBy(int* count, int n) {
		(*count) += n;
		}

		TEST_F(SingleObserverRegistryTest, wrapped_callback) {
		int count = 0;
		auto wrapped_callback = registry_->Register(Bind(&Increment, Unretained(&count)));
		wrapped_callback.Run();
		EXPECT_EQ(count, 1);
		wrapped_callback.Run();
		EXPECT_EQ(count, 2);
		wrapped_callback.Run();
		EXPECT_EQ(count, 3);
		registry_->Unregister();
		}

		TEST_F(SingleObserverRegistryTest, unregister) {
		int count = 0;
		auto wrapped_callback = registry_->Register(Bind(&Increment, Unretained(&count)));
		registry_->Unregister();
		wrapped_callback.Run();
		EXPECT_EQ(count, 0);
		}

		TEST_F(SingleObserverRegistryTest, second_register) {
		int count = 0;
		auto wrapped_callback = registry_->Register(Bind(&Increment, Unretained(&count)));
		registry_->Unregister();
		auto wrapped_callback2 = registry_->Register(Bind(&Increment, Unretained(&count)));
		wrapped_callback.Run();
		EXPECT_EQ(count, 0);
		wrapped_callback2.Run();
		EXPECT_EQ(count, 1);
		}

		class MultipleObserverRegistryTest : public ::testing::Test {
		protected:
		void SetUp() override {
		registry_ = new MultipleObserverRegistry<2>;
		}

		void TearDown() override {
		delete registry_;
		}

		MultipleObserverRegistry<2>* registry_;
		};

		TEST_F(MultipleObserverRegistryTest, single_wrapped_callback) {
		int count = 0;
		auto wrapped_callback = registry_->Register(0, Bind(&Increment, Unretained(&count)));
		wrapped_callback.Run();
		EXPECT_EQ(count, 1);
		wrapped_callback.Run();
		EXPECT_EQ(count, 2);
		wrapped_callback.Run();
		EXPECT_EQ(count, 3);
		registry_->Unregister(0);
		}

		TEST_F(MultipleObserverRegistryTest, multiple_wrapped_callback) {
		int count = 0;
		auto wrapped_callback0 = registry_->Register(0, Bind(&Increment, Unretained(&count)));
		auto wrapped_callback1 = registry_->Register(1, Bind(&IncrementBy, Unretained(&count), 10));
		wrapped_callback0.Run();
		EXPECT_EQ(count, 1);
		wrapped_callback1.Run();
		EXPECT_EQ(count, 11);
		registry_->Unregister(0);
		wrapped_callback0.Run();
		EXPECT_EQ(count, 11);
		wrapped_callback1.Run();
		EXPECT_EQ(count, 21);
		registry_->Unregister(1);
		EXPECT_EQ(count, 21);
		}

		} // namespace common
		} // namespace bluetooth

system/gd/storage/storage_module.cc

+0 −2

Original line number	Diff line number	Diff line
		@@ -36,8 +36,6 @@
		namespace bluetooth {
		namespace storage {

		using common::ListMap;
		using common::LruCache;
		using os::Alarm;
		using os::Handler;