convert ResourceManager usage in MediaCodec to ndk aidl
bug: 142396029
test: ResourceManagerService_test, DrmSessionManager_test,
CTS ResourceManagerTest, manual test battery stats and cpuset
Change-Id: I77f5de54a83b17d906798659e1b3281c90cde92c
diff --git a/services/mediaresourcemanager/Android.bp b/services/mediaresourcemanager/Android.bp
index d468406..a3519d5 100644
--- a/services/mediaresourcemanager/Android.bp
+++ b/services/mediaresourcemanager/Android.bp
@@ -12,6 +12,7 @@
"libmedia",
"libmediautils",
"libbinder",
+ "libbinder_ndk",
"libutils",
"liblog",
],
diff --git a/services/mediaresourcemanager/ResourceManagerService.cpp b/services/mediaresourcemanager/ResourceManagerService.cpp
index ae832c7..877c44d 100644
--- a/services/mediaresourcemanager/ResourceManagerService.cpp
+++ b/services/mediaresourcemanager/ResourceManagerService.cpp
@@ -19,6 +19,8 @@
#define LOG_TAG "ResourceManagerService"
#include <utils/Log.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
#include <binder/IMediaResourceMonitor.h>
#include <binder/IServiceManager.h>
#include <cutils/sched_policy.h>
@@ -38,28 +40,25 @@
namespace android {
-namespace media {
+DeathNotifier::DeathNotifier(const std::shared_ptr<ResourceManagerService> &service,
+ int pid, int64_t clientId)
+ : mService(service), mPid(pid), mClientId(clientId) {}
-class DeathNotifier : public IBinder::DeathRecipient {
-public:
- DeathNotifier(const wp<ResourceManagerService> &service, int pid, int64_t clientId)
- : mService(service), mPid(pid), mClientId(clientId) {}
+//static
+void DeathNotifier::BinderDiedCallback(void* cookie) {
+ auto thiz = static_cast<DeathNotifier*>(cookie);
+ thiz->binderDied();
+}
- virtual void binderDied(const wp<IBinder> & /* who */) override {
- // Don't check for pid validity since we know it's already dead.
- sp<ResourceManagerService> service = mService.promote();
- if (service == nullptr) {
- ALOGW("ResourceManagerService is dead as well.");
- return;
- }
- service->removeResource(mPid, mClientId, false);
+void DeathNotifier::binderDied() {
+ // Don't check for pid validity since we know it's already dead.
+ std::shared_ptr<ResourceManagerService> service = mService.lock();
+ if (service == nullptr) {
+ ALOGW("ResourceManagerService is dead as well.");
+ return;
}
-
-private:
- wp<ResourceManagerService> mService;
- int mPid;
- int64_t mClientId;
-};
+ service->removeResource(mPid, mClientId, false);
+}
template <typename T>
static String8 getString(const std::vector<T> &items) {
@@ -104,7 +103,7 @@
static ResourceInfo& getResourceInfoForEdit(
uid_t uid,
int64_t clientId,
- const sp<IResourceManagerClient>& client,
+ const std::shared_ptr<IResourceManagerClient>& client,
ResourceInfos& infos) {
ssize_t index = infos.indexOfKey(clientId);
@@ -135,14 +134,15 @@
}
}
-status_t ResourceManagerService::dump(int fd, const Vector<String16>& /* args */) {
+binder_status_t ResourceManagerService::dump(
+ int fd, const char** /*args*/, uint32_t /*numArgs*/) {
String8 result;
if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
result.format("Permission Denial: "
"can't dump ResourceManagerService from pid=%d, uid=%d\n",
- IPCThreadState::self()->getCallingPid(),
- IPCThreadState::self()->getCallingUid());
+ AIBinder_getCallingPid(),
+ AIBinder_getCallingUid());
write(fd, result.string(), result.size());
return PERMISSION_DENIED;
}
@@ -206,7 +206,7 @@
struct SystemCallbackImpl :
public ResourceManagerService::SystemCallbackInterface {
- SystemCallbackImpl() {}
+ SystemCallbackImpl() : mClientToken(new BBinder()) {}
virtual void noteStartVideo(int uid) override {
BatteryNotifier::getInstance().noteStartVideo(uid);
@@ -217,9 +217,8 @@
virtual void noteResetVideo() override {
BatteryNotifier::getInstance().noteResetVideo();
}
- virtual bool requestCpusetBoost(
- bool enable, const sp<IInterface> &client) override {
- return android::requestCpusetBoost(enable, client);
+ virtual bool requestCpusetBoost(bool enable) override {
+ return android::requestCpusetBoost(enable, mClientToken);
}
protected:
@@ -227,6 +226,7 @@
private:
DISALLOW_EVIL_CONSTRUCTORS(SystemCallbackImpl);
+ sp<IBinder> mClientToken;
};
ResourceManagerService::ResourceManagerService()
@@ -240,10 +240,26 @@
mServiceLog(new ServiceLog()),
mSupportsMultipleSecureCodecs(true),
mSupportsSecureWithNonSecureCodec(true),
- mCpuBoostCount(0) {
+ mCpuBoostCount(0),
+ mDeathRecipient(AIBinder_DeathRecipient_new(DeathNotifier::BinderDiedCallback)) {
mSystemCB->noteResetVideo();
}
+//static
+void ResourceManagerService::instantiate() {
+ std::shared_ptr<ResourceManagerService> service =
+ ::ndk::SharedRefBase::make<ResourceManagerService>();
+ binder_status_t status =
+ AServiceManager_addService(service->asBinder().get(), getServiceName());
+ if (status != STATUS_OK) {
+ return;
+ }
+ // TODO: mediaserver main() is already starting the thread pool,
+ // move this to mediaserver main() when other services in mediaserver
+ // are converted to ndk-platform aidl.
+ //ABinderProcess_startThreadPool();
+}
+
ResourceManagerService::~ResourceManagerService() {}
Status ResourceManagerService::config(const std::vector<MediaResourcePolicyParcel>& policies) {
@@ -271,7 +287,7 @@
// Request it on every new instance of kCpuBoost, as the media.codec
// could have died, if we only do it the first time subsequent instances
// never gets the boost.
- if (mSystemCB->requestCpusetBoost(true, this) != OK) {
+ if (mSystemCB->requestCpusetBoost(true) != OK) {
ALOGW("couldn't request cpuset boost");
}
mCpuBoostCount++;
@@ -287,7 +303,7 @@
&& resource.subType == MediaResource::SubType::kUnspecifiedSubType
&& mCpuBoostCount > 0) {
if (--mCpuBoostCount == 0) {
- mSystemCB->requestCpusetBoost(false, this);
+ mSystemCB->requestCpusetBoost(false);
}
} else if (resource.type == MediaResource::Type::kBattery
&& resource.subType == MediaResource::SubType::kVideoCodec) {
@@ -316,7 +332,7 @@
int32_t pid,
int32_t uid,
int64_t clientId,
- const sp<IResourceManagerClient>& client,
+ const std::shared_ptr<IResourceManagerClient>& client,
const std::vector<MediaResourceParcel>& resources) {
String8 log = String8::format("addResource(pid %d, clientId %lld, resources %s)",
pid, (long long) clientId, getString(resources).string());
@@ -352,8 +368,9 @@
}
}
if (info.deathNotifier == nullptr && client != nullptr) {
- info.deathNotifier = new DeathNotifier(this, pid, clientId);
- IInterface::asBinder(client)->linkToDeath(info.deathNotifier);
+ info.deathNotifier = new DeathNotifier(ref<ResourceManagerService>(), pid, clientId);
+ AIBinder_linkToDeath(client->asBinder().get(),
+ mDeathRecipient.get(), info.deathNotifier.get());
}
notifyResourceGranted(pid, resources);
return Status::ok();
@@ -442,18 +459,20 @@
onLastRemoved(it->second, info);
}
- IInterface::asBinder(info.client)->unlinkToDeath(info.deathNotifier);
+ AIBinder_unlinkToDeath(info.client->asBinder().get(),
+ mDeathRecipient.get(), info.deathNotifier.get());
infos.removeItemsAt(index);
return Status::ok();
}
void ResourceManagerService::getClientForResource_l(
- int callingPid, const MediaResourceParcel *res, Vector<sp<IResourceManagerClient>> *clients) {
+ int callingPid, const MediaResourceParcel *res,
+ Vector<std::shared_ptr<IResourceManagerClient>> *clients) {
if (res == NULL) {
return;
}
- sp<IResourceManagerClient> client;
+ std::shared_ptr<IResourceManagerClient> client;
if (getLowestPriorityBiggestClient_l(callingPid, res->type, &client)) {
clients->push_back(client);
}
@@ -468,7 +487,7 @@
mServiceLog->add(log);
*_aidl_return = false;
- Vector<sp<IResourceManagerClient>> clients;
+ Vector<std::shared_ptr<IResourceManagerClient>> clients;
{
Mutex::Autolock lock(mLock);
if (!mProcessInfo->isValidPid(callingPid)) {
@@ -547,7 +566,7 @@
return Status::ok();
}
- sp<IResourceManagerClient> failedClient;
+ std::shared_ptr<IResourceManagerClient> failedClient;
for (size_t i = 0; i < clients.size(); ++i) {
log = String8::format("reclaimResource from client %p", clients[i].get());
mServiceLog->add(log);
@@ -590,8 +609,9 @@
}
bool ResourceManagerService::getAllClients_l(
- int callingPid, MediaResource::Type type, Vector<sp<IResourceManagerClient>> *clients) {
- Vector<sp<IResourceManagerClient>> temp;
+ int callingPid, MediaResource::Type type,
+ Vector<std::shared_ptr<IResourceManagerClient>> *clients) {
+ Vector<std::shared_ptr<IResourceManagerClient>> temp;
for (size_t i = 0; i < mMap.size(); ++i) {
ResourceInfos &infos = mMap.editValueAt(i);
for (size_t j = 0; j < infos.size(); ++j) {
@@ -616,7 +636,8 @@
}
bool ResourceManagerService::getLowestPriorityBiggestClient_l(
- int callingPid, MediaResource::Type type, sp<IResourceManagerClient> *client) {
+ int callingPid, MediaResource::Type type,
+ std::shared_ptr<IResourceManagerClient> *client) {
int lowestPriorityPid;
int lowestPriority;
int callingPriority;
@@ -688,14 +709,14 @@
}
bool ResourceManagerService::getBiggestClient_l(
- int pid, MediaResource::Type type, sp<IResourceManagerClient> *client) {
+ int pid, MediaResource::Type type, std::shared_ptr<IResourceManagerClient> *client) {
ssize_t index = mMap.indexOfKey(pid);
if (index < 0) {
ALOGE("getBiggestClient_l: can't find resource info for pid %d", pid);
return false;
}
- sp<IResourceManagerClient> clientTemp;
+ std::shared_ptr<IResourceManagerClient> clientTemp;
uint64_t largestValue = 0;
const ResourceInfos &infos = mMap.valueAt(index);
for (size_t i = 0; i < infos.size(); ++i) {
@@ -720,5 +741,4 @@
return true;
}
-} // namespace media
} // namespace android
diff --git a/services/mediaresourcemanager/ResourceManagerService.h b/services/mediaresourcemanager/ResourceManagerService.h
index b5b9f86..ae12d7b 100644
--- a/services/mediaresourcemanager/ResourceManagerService.h
+++ b/services/mediaresourcemanager/ResourceManagerService.h
@@ -18,9 +18,8 @@
#ifndef ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H
#define ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H
-#include <android/media/BnResourceManagerService.h>
+#include <aidl/android/media/BnResourceManagerService.h>
#include <arpa/inet.h>
-#include <binder/BinderService.h>
#include <media/MediaResource.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
@@ -30,22 +29,26 @@
namespace android {
+class DeathNotifier;
+class ResourceManagerService;
class ServiceLog;
struct ProcessInfoInterface;
-namespace media {
-
-using android::binder::Status;
+using Status = ::ndk::ScopedAStatus;
+using ::aidl::android::media::IResourceManagerClient;
+using ::aidl::android::media::BnResourceManagerService;
+using ::aidl::android::media::MediaResourceParcel;
+using ::aidl::android::media::MediaResourcePolicyParcel;
typedef std::map<std::tuple<
- MediaResource::Type, MediaResource::SubType, std::vector<uint8_t>>,
+ MediaResource::Type, MediaResource::SubType, std::vector<int8_t>>,
MediaResourceParcel> ResourceList;
struct ResourceInfo {
int64_t clientId;
uid_t uid;
- sp<IResourceManagerClient> client;
- sp<IBinder::DeathRecipient> deathNotifier;
+ std::shared_ptr<IResourceManagerClient> client;
+ sp<DeathNotifier> deathNotifier;
ResourceList resources;
};
@@ -53,27 +56,42 @@
typedef KeyedVector<int64_t, ResourceInfo> ResourceInfos;
typedef KeyedVector<int, ResourceInfos> PidResourceInfosMap;
-class ResourceManagerService
- : public BinderService<ResourceManagerService>,
- public BnResourceManagerService
-{
+class DeathNotifier : public RefBase {
+public:
+ DeathNotifier(const std::shared_ptr<ResourceManagerService> &service,
+ int pid, int64_t clientId);
+
+ ~DeathNotifier() {}
+
+ // Implement death recipient
+ static void BinderDiedCallback(void* cookie);
+ void binderDied();
+
+private:
+ std::weak_ptr<ResourceManagerService> mService;
+ int mPid;
+ int64_t mClientId;
+};
+class ResourceManagerService : public BnResourceManagerService {
public:
struct SystemCallbackInterface : public RefBase {
virtual void noteStartVideo(int uid) = 0;
virtual void noteStopVideo(int uid) = 0;
virtual void noteResetVideo() = 0;
- virtual bool requestCpusetBoost(
- bool enable, const sp<IInterface> &client) = 0;
+ virtual bool requestCpusetBoost(bool enable) = 0;
};
static char const *getServiceName() { return "media.resource_manager"; }
+ static void instantiate();
- virtual status_t dump(int fd, const Vector<String16>& args);
+ virtual inline binder_status_t dump(
+ int /*fd*/, const char** /*args*/, uint32_t /*numArgs*/);
ResourceManagerService();
explicit ResourceManagerService(
const sp<ProcessInfoInterface> &processInfo,
const sp<SystemCallbackInterface> &systemResource);
+ virtual ~ResourceManagerService();
// IResourceManagerService interface
Status config(const std::vector<MediaResourcePolicyParcel>& policies) override;
@@ -82,7 +100,7 @@
int32_t pid,
int32_t uid,
int64_t clientId,
- const sp<IResourceManagerClient>& client,
+ const std::shared_ptr<IResourceManagerClient>& client,
const std::vector<MediaResourceParcel>& resources) override;
Status removeResource(
@@ -102,9 +120,6 @@
Status removeResource(int pid, int64_t clientId, bool checkValid);
-protected:
- virtual ~ResourceManagerService();
-
private:
friend class ResourceManagerServiceTest;
@@ -112,13 +127,13 @@
// Returns false if any client belongs to a process with higher priority than the
// calling process. The clients will remain unchanged if returns false.
bool getAllClients_l(int callingPid, MediaResource::Type type,
- Vector<sp<IResourceManagerClient>> *clients);
+ Vector<std::shared_ptr<IResourceManagerClient>> *clients);
// Gets the client who owns specified resource type from lowest possible priority process.
// Returns false if the calling process priority is not higher than the lowest process
// priority. The client will remain unchanged if returns false.
bool getLowestPriorityBiggestClient_l(int callingPid, MediaResource::Type type,
- sp<IResourceManagerClient> *client);
+ std::shared_ptr<IResourceManagerClient> *client);
// Gets lowest priority process that has the specified resource type.
// Returns false if failed. The output parameters will remain unchanged if failed.
@@ -126,14 +141,15 @@
// Gets the client who owns biggest piece of specified resource type from pid.
// Returns false if failed. The client will remain unchanged if failed.
- bool getBiggestClient_l(int pid, MediaResource::Type type, sp<IResourceManagerClient> *client);
+ bool getBiggestClient_l(int pid, MediaResource::Type type,
+ std::shared_ptr<IResourceManagerClient> *client);
bool isCallingPriorityHigher_l(int callingPid, int pid);
- // A helper function basically calls getLowestPriorityBiggestClient_l and add the result client
- // to the given Vector.
- void getClientForResource_l(int callingPid,
- const MediaResourceParcel *res, Vector<sp<IResourceManagerClient>> *clients);
+ // A helper function basically calls getLowestPriorityBiggestClient_l and add
+ // the result client to the given Vector.
+ void getClientForResource_l(int callingPid, const MediaResourceParcel *res,
+ Vector<std::shared_ptr<IResourceManagerClient>> *clients);
void onFirstAdded(const MediaResourceParcel& res, const ResourceInfo& clientInfo);
void onLastRemoved(const MediaResourceParcel& res, const ResourceInfo& clientInfo);
@@ -149,10 +165,10 @@
bool mSupportsMultipleSecureCodecs;
bool mSupportsSecureWithNonSecureCodec;
int32_t mCpuBoostCount;
+ ::ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
};
// ----------------------------------------------------------------------------
-} // namespace media
} // namespace android
#endif // ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H
diff --git a/services/mediaresourcemanager/test/Android.bp b/services/mediaresourcemanager/test/Android.bp
index 543c87c..b6c548c 100644
--- a/services/mediaresourcemanager/test/Android.bp
+++ b/services/mediaresourcemanager/test/Android.bp
@@ -5,6 +5,7 @@
test_suites: ["device-tests"],
shared_libs: [
"libbinder",
+ "libbinder_ndk",
"liblog",
"libmedia",
"libresourcemanagerservice",
diff --git a/services/mediaresourcemanager/test/ResourceManagerService_test.cpp b/services/mediaresourcemanager/test/ResourceManagerService_test.cpp
index 203baf5..168fde9 100644
--- a/services/mediaresourcemanager/test/ResourceManagerService_test.cpp
+++ b/services/mediaresourcemanager/test/ResourceManagerService_test.cpp
@@ -21,18 +21,28 @@
#include <gtest/gtest.h>
#include "ResourceManagerService.h"
-#include <android/media/BnResourceManagerClient.h>
+#include <aidl/android/media/BnResourceManagerClient.h>
#include <media/MediaResource.h>
#include <media/MediaResourcePolicy.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/ProcessInfoInterface.h>
+namespace aidl {
namespace android {
namespace media {
+bool operator== (const MediaResourceParcel& lhs, const MediaResourceParcel& rhs) {
+ return lhs.type == rhs.type && lhs.subType == rhs.subType &&
+ lhs.id == rhs.id && lhs.value == rhs.value;
+}}}}
-using ::android::binder::Status;
+namespace android {
-static int64_t getId(const sp<IResourceManagerClient>& client) {
+using Status = ::ndk::ScopedAStatus;
+using ::aidl::android::media::BnResourceManagerClient;
+using ::aidl::android::media::IResourceManagerService;
+using ::aidl::android::media::IResourceManagerClient;
+
+static int64_t getId(const std::shared_ptr<IResourceManagerClient>& client) {
return (int64_t) client.get();
}
@@ -89,8 +99,7 @@
mEventCount++;
}
- virtual bool requestCpusetBoost(
- bool enable, const sp<IInterface> &/*client*/) override {
+ virtual bool requestCpusetBoost(bool enable) override {
mLastEvent = {enable ? EventType::CPUSET_ENABLE : EventType::CPUSET_DISABLE, 0};
mEventCount++;
return true;
@@ -112,12 +121,11 @@
struct TestClient : public BnResourceManagerClient {
- TestClient(int pid, sp<ResourceManagerService> service)
+ TestClient(int pid, const std::shared_ptr<ResourceManagerService> &service)
: mReclaimed(false), mPid(pid), mService(service) {}
Status reclaimResource(bool* _aidl_return) override {
- sp<IResourceManagerClient> client(this);
- mService->removeClient(mPid, (int64_t) client.get());
+ mService->removeClient(mPid, getId(ref<TestClient>()));
mReclaimed = true;
*_aidl_return = true;
return Status::ok();
@@ -136,13 +144,12 @@
mReclaimed = false;
}
-protected:
virtual ~TestClient() {}
private:
bool mReclaimed;
int mPid;
- sp<ResourceManagerService> mService;
+ std::shared_ptr<ResourceManagerService> mService;
DISALLOW_EVIL_CONSTRUCTORS(TestClient);
};
@@ -172,10 +179,11 @@
public:
ResourceManagerServiceTest()
: mSystemCB(new TestSystemCallback()),
- mService(new ResourceManagerService(new TestProcessInfo, mSystemCB)),
- mTestClient1(new TestClient(kTestPid1, mService)),
- mTestClient2(new TestClient(kTestPid2, mService)),
- mTestClient3(new TestClient(kTestPid2, mService)) {
+ mService(::ndk::SharedRefBase::make<ResourceManagerService>(
+ new TestProcessInfo, mSystemCB)),
+ mTestClient1(::ndk::SharedRefBase::make<TestClient>(kTestPid1, mService)),
+ mTestClient2(::ndk::SharedRefBase::make<TestClient>(kTestPid2, mService)),
+ mTestClient3(::ndk::SharedRefBase::make<TestClient>(kTestPid2, mService)) {
}
protected:
@@ -193,7 +201,7 @@
static void expectEqResourceInfo(const ResourceInfo &info,
int uid,
- sp<IResourceManagerClient> client,
+ std::shared_ptr<IResourceManagerClient> client,
const std::vector<MediaResourceParcel> &resources) {
EXPECT_EQ(uid, info.uid);
EXPECT_EQ(client, info.client);
@@ -334,11 +342,11 @@
std::vector<MediaResourcePolicyParcel> policies1;
policies1.push_back(
MediaResourcePolicy(
- IResourceManagerService::kPolicySupportsMultipleSecureCodecs(),
+ IResourceManagerService::kPolicySupportsMultipleSecureCodecs,
"true"));
policies1.push_back(
MediaResourcePolicy(
- IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec(),
+ IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec,
"false"));
mService->config(policies1);
EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs);
@@ -347,11 +355,11 @@
std::vector<MediaResourcePolicyParcel> policies2;
policies2.push_back(
MediaResourcePolicy(
- IResourceManagerService::kPolicySupportsMultipleSecureCodecs(),
+ IResourceManagerService::kPolicySupportsMultipleSecureCodecs,
"false"));
policies2.push_back(
MediaResourcePolicy(
- IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec(),
+ IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec,
"true"));
mService->config(policies2);
EXPECT_FALSE(mService->mSupportsMultipleSecureCodecs);
@@ -458,7 +466,7 @@
addResource();
MediaResource::Type type = MediaResource::Type::kSecureCodec;
- Vector<sp<IResourceManagerClient> > clients;
+ Vector<std::shared_ptr<IResourceManagerClient> > clients;
EXPECT_FALSE(mService->getAllClients_l(kLowPriorityPid, type, &clients));
// some higher priority process (e.g. kTestPid2) owns the resource, so getAllClients_l
// will fail.
@@ -667,7 +675,7 @@
void testGetLowestPriorityBiggestClient() {
MediaResource::Type type = MediaResource::Type::kGraphicMemory;
- sp<IResourceManagerClient> client;
+ std::shared_ptr<IResourceManagerClient> client;
EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(kHighPriorityPid, type, &client));
addResource();
@@ -706,7 +714,7 @@
void testGetBiggestClient() {
MediaResource::Type type = MediaResource::Type::kGraphicMemory;
- sp<IResourceManagerClient> client;
+ std::shared_ptr<IResourceManagerClient> client;
EXPECT_FALSE(mService->getBiggestClient_l(kTestPid2, type, &client));
addResource();
@@ -799,10 +807,10 @@
}
sp<TestSystemCallback> mSystemCB;
- sp<ResourceManagerService> mService;
- sp<IResourceManagerClient> mTestClient1;
- sp<IResourceManagerClient> mTestClient2;
- sp<IResourceManagerClient> mTestClient3;
+ std::shared_ptr<ResourceManagerService> mService;
+ std::shared_ptr<IResourceManagerClient> mTestClient1;
+ std::shared_ptr<IResourceManagerClient> mTestClient2;
+ std::shared_ptr<IResourceManagerClient> mTestClient3;
};
TEST_F(ResourceManagerServiceTest, config) {
@@ -862,5 +870,4 @@
testCpusetBoost();
}
-} // namespace media
} // namespace android