Convert IResourceManagerService to stable AIDL
Convert with minimal change to the interface itself.
Add additional test to cover DrmSessionManager's usage
of possible negative value field (which is signed now).
bug: 142396029
test: ResourceManagerService_test, DrmSessionManager_test,
CTS ResourceManagerServiceTest;
Manually check battery stats reporting.
Change-Id: I5c537a54efc2663281c96ddbdbd4ee56f23c1adf
diff --git a/services/mediaresourcemanager/ResourceManagerService.cpp b/services/mediaresourcemanager/ResourceManagerService.cpp
index 45eea0f..ae832c7 100644
--- a/services/mediaresourcemanager/ResourceManagerService.cpp
+++ b/services/mediaresourcemanager/ResourceManagerService.cpp
@@ -23,6 +23,7 @@
#include <binder/IServiceManager.h>
#include <cutils/sched_policy.h>
#include <dirent.h>
+#include <media/MediaResourcePolicy.h>
#include <media/stagefright/ProcessInfo.h>
#include <mediautils/BatteryNotifier.h>
#include <mediautils/SchedulingPolicyService.h>
@@ -37,7 +38,7 @@
namespace android {
-namespace {
+namespace media {
class DeathNotifier : public IBinder::DeathRecipient {
public:
@@ -60,20 +61,18 @@
int64_t mClientId;
};
-} // namespace
-
template <typename T>
-static String8 getString(const Vector<T> &items) {
+static String8 getString(const std::vector<T> &items) {
String8 itemsStr;
for (size_t i = 0; i < items.size(); ++i) {
- itemsStr.appendFormat("%s ", items[i].toString().string());
+ itemsStr.appendFormat("%s ", toString(items[i]).string());
}
return itemsStr;
}
static bool hasResourceType(MediaResource::Type type, const ResourceList& resources) {
for (auto it = resources.begin(); it != resources.end(); it++) {
- if (it->second.mType == type) {
+ if (it->second.type == type) {
return true;
}
}
@@ -121,15 +120,15 @@
return infos.editValueAt(index);
}
-static void notifyResourceGranted(int pid, const Vector<MediaResource> &resources) {
+static void notifyResourceGranted(int pid, const std::vector<MediaResourceParcel> &resources) {
static const char* const kServiceName = "media_resource_monitor";
sp<IBinder> binder = defaultServiceManager()->checkService(String16(kServiceName));
if (binder != NULL) {
sp<IMediaResourceMonitor> service = interface_cast<IMediaResourceMonitor>(binder);
for (size_t i = 0; i < resources.size(); ++i) {
- if (resources[i].mSubType == MediaResource::kAudioCodec) {
+ if (resources[i].subType == MediaResource::SubType::kAudioCodec) {
service->notifyResourceGranted(pid, IMediaResourceMonitor::TYPE_AUDIO_CODEC);
- } else if (resources[i].mSubType == MediaResource::kVideoCodec) {
+ } else if (resources[i].subType == MediaResource::SubType::kVideoCodec) {
service->notifyResourceGranted(pid, IMediaResourceMonitor::TYPE_VIDEO_CODEC);
}
}
@@ -182,13 +181,18 @@
snprintf(buffer, SIZE, " Id: %lld\n", (long long)infos[j].clientId);
result.append(buffer);
- snprintf(buffer, SIZE, " Name: %s\n", infos[j].client->getName().string());
+ std::string clientName;
+ Status status = infos[j].client->getName(&clientName);
+ if (!status.isOk()) {
+ clientName = "<unknown client>";
+ }
+ snprintf(buffer, SIZE, " Name: %s\n", clientName.c_str());
result.append(buffer);
const ResourceList &resources = infos[j].resources;
result.append(" Resources:\n");
for (auto it = resources.begin(); it != resources.end(); it++) {
- snprintf(buffer, SIZE, " %s\n", it->second.toString().string());
+ snprintf(buffer, SIZE, " %s\n", toString(it->second).string());
result.append(buffer);
}
}
@@ -242,27 +246,28 @@
ResourceManagerService::~ResourceManagerService() {}
-void ResourceManagerService::config(const Vector<MediaResourcePolicy> &policies) {
+Status ResourceManagerService::config(const std::vector<MediaResourcePolicyParcel>& policies) {
String8 log = String8::format("config(%s)", getString(policies).string());
mServiceLog->add(log);
Mutex::Autolock lock(mLock);
for (size_t i = 0; i < policies.size(); ++i) {
- String8 type = policies[i].mType;
- String8 value = policies[i].mValue;
- if (type == kPolicySupportsMultipleSecureCodecs) {
+ const std::string &type = policies[i].type;
+ const std::string &value = policies[i].value;
+ if (type == MediaResourcePolicy::kPolicySupportsMultipleSecureCodecs()) {
mSupportsMultipleSecureCodecs = (value == "true");
- } else if (type == kPolicySupportsSecureWithNonSecureCodec) {
+ } else if (type == MediaResourcePolicy::kPolicySupportsSecureWithNonSecureCodec()) {
mSupportsSecureWithNonSecureCodec = (value == "true");
}
}
+ return Status::ok();
}
void ResourceManagerService::onFirstAdded(
- const MediaResource& resource, const ResourceInfo& clientInfo) {
+ const MediaResourceParcel& resource, const ResourceInfo& clientInfo) {
// first time added
- if (resource.mType == MediaResource::kCpuBoost
- && resource.mSubType == MediaResource::kUnspecifiedSubType) {
+ if (resource.type == MediaResource::Type::kCpuBoost
+ && resource.subType == MediaResource::SubType::kUnspecifiedSubType) {
// 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.
@@ -270,44 +275,49 @@
ALOGW("couldn't request cpuset boost");
}
mCpuBoostCount++;
- } else if (resource.mType == MediaResource::kBattery
- && resource.mSubType == MediaResource::kVideoCodec) {
+ } else if (resource.type == MediaResource::Type::kBattery
+ && resource.subType == MediaResource::SubType::kVideoCodec) {
mSystemCB->noteStartVideo(clientInfo.uid);
}
}
void ResourceManagerService::onLastRemoved(
- const MediaResource& resource, const ResourceInfo& clientInfo) {
- if (resource.mType == MediaResource::kCpuBoost
- && resource.mSubType == MediaResource::kUnspecifiedSubType
+ const MediaResourceParcel& resource, const ResourceInfo& clientInfo) {
+ if (resource.type == MediaResource::Type::kCpuBoost
+ && resource.subType == MediaResource::SubType::kUnspecifiedSubType
&& mCpuBoostCount > 0) {
if (--mCpuBoostCount == 0) {
mSystemCB->requestCpusetBoost(false, this);
}
- } else if (resource.mType == MediaResource::kBattery
- && resource.mSubType == MediaResource::kVideoCodec) {
+ } else if (resource.type == MediaResource::Type::kBattery
+ && resource.subType == MediaResource::SubType::kVideoCodec) {
mSystemCB->noteStopVideo(clientInfo.uid);
}
}
void ResourceManagerService::mergeResources(
- MediaResource& r1, const MediaResource& r2) {
- if (r1.mType == MediaResource::kDrmSession) {
- // This means we are using a session. Each session's mValue is initialized to UINT64_MAX.
- // The oftener a session is used the lower it's mValue. During reclaim the session with
- // the highest mValue/lowest usage would be closed.
- r1.mValue -= (r1.mValue == 0 ? 0 : 1);
+ MediaResourceParcel& r1, const MediaResourceParcel& r2) {
+ // The resource entry on record is maintained to be in [0,INT64_MAX].
+ // Clamp if merging in the new resource value causes it to go out of bound.
+ // Note that the new resource value could be negative, eg.DrmSession, the
+ // value goes lower when the session is used more often. During reclaim
+ // the session with the highest value (lowest usage) would be closed.
+ if (r2.value < INT64_MAX - r1.value) {
+ r1.value += r2.value;
+ if (r1.value < 0) {
+ r1.value = 0;
+ }
} else {
- r1.mValue += r2.mValue;
+ r1.value = INT64_MAX;
}
}
-void ResourceManagerService::addResource(
- int pid,
- int uid,
+Status ResourceManagerService::addResource(
+ int32_t pid,
+ int32_t uid,
int64_t clientId,
- const sp<IResourceManagerClient> client,
- const Vector<MediaResource> &resources) {
+ const sp<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());
mServiceLog->add(log);
@@ -315,15 +325,26 @@
Mutex::Autolock lock(mLock);
if (!mProcessInfo->isValidPid(pid)) {
ALOGE("Rejected addResource call with invalid pid.");
- return;
+ return Status::fromServiceSpecificError(BAD_VALUE);
}
ResourceInfos& infos = getResourceInfosForEdit(pid, mMap);
ResourceInfo& info = getResourceInfoForEdit(uid, clientId, client, infos);
for (size_t i = 0; i < resources.size(); ++i) {
const auto &res = resources[i];
- const auto resType = std::tuple(res.mType, res.mSubType, res.mId);
+ const auto resType = std::tuple(res.type, res.subType, res.id);
+
+ if (res.value < 0 && res.type != MediaResource::Type::kDrmSession) {
+ ALOGW("Ignoring request to remove negative value of non-drm resource");
+ continue;
+ }
if (info.resources.find(resType) == info.resources.end()) {
+ if (res.value <= 0) {
+ // We can't init a new entry with negative value, although it's allowed
+ // to merge in negative values after the initial add.
+ ALOGW("Ignoring request to add new resource entry with value <= 0");
+ continue;
+ }
onFirstAdded(res, info);
info.resources[resType] = res;
} else {
@@ -335,10 +356,12 @@
IInterface::asBinder(client)->linkToDeath(info.deathNotifier);
}
notifyResourceGranted(pid, resources);
+ return Status::ok();
}
-void ResourceManagerService::removeResource(int pid, int64_t clientId,
- const Vector<MediaResource> &resources) {
+Status ResourceManagerService::removeResource(
+ int32_t pid, int64_t clientId,
+ const std::vector<MediaResourceParcel>& resources) {
String8 log = String8::format("removeResource(pid %d, clientId %lld, resources %s)",
pid, (long long) clientId, getString(resources).string());
mServiceLog->add(log);
@@ -346,46 +369,51 @@
Mutex::Autolock lock(mLock);
if (!mProcessInfo->isValidPid(pid)) {
ALOGE("Rejected removeResource call with invalid pid.");
- return;
+ return Status::fromServiceSpecificError(BAD_VALUE);
}
ssize_t index = mMap.indexOfKey(pid);
if (index < 0) {
ALOGV("removeResource: didn't find pid %d for clientId %lld", pid, (long long) clientId);
- return;
+ return Status::ok();
}
ResourceInfos &infos = mMap.editValueAt(index);
index = infos.indexOfKey(clientId);
if (index < 0) {
ALOGV("removeResource: didn't find clientId %lld", (long long) clientId);
- return;
+ return Status::ok();
}
ResourceInfo &info = infos.editValueAt(index);
for (size_t i = 0; i < resources.size(); ++i) {
const auto &res = resources[i];
- const auto resType = std::tuple(res.mType, res.mSubType, res.mId);
+ const auto resType = std::tuple(res.type, res.subType, res.id);
+
+ if (res.value < 0) {
+ ALOGW("Ignoring request to remove negative value of resource");
+ continue;
+ }
// ignore if we don't have it
if (info.resources.find(resType) != info.resources.end()) {
- MediaResource &resource = info.resources[resType];
- if (resource.mValue > res.mValue) {
- resource.mValue -= res.mValue;
+ MediaResourceParcel &resource = info.resources[resType];
+ if (resource.value > res.value) {
+ resource.value -= res.value;
} else {
- // drm sessions always take this branch because res.mValue is set
- // to UINT64_MAX
onLastRemoved(res, info);
info.resources.erase(resType);
}
}
}
+ return Status::ok();
}
-void ResourceManagerService::removeClient(int pid, int64_t clientId) {
+Status ResourceManagerService::removeClient(int32_t pid, int64_t clientId) {
removeResource(pid, clientId, true);
+ return Status::ok();
}
-void ResourceManagerService::removeResource(int pid, int64_t clientId, bool checkValid) {
+Status ResourceManagerService::removeResource(int pid, int64_t clientId, bool checkValid) {
String8 log = String8::format(
"removeResource(pid %d, clientId %lld)",
pid, (long long) clientId);
@@ -394,19 +422,19 @@
Mutex::Autolock lock(mLock);
if (checkValid && !mProcessInfo->isValidPid(pid)) {
ALOGE("Rejected removeResource call with invalid pid.");
- return;
+ return Status::fromServiceSpecificError(BAD_VALUE);
}
ssize_t index = mMap.indexOfKey(pid);
if (index < 0) {
ALOGV("removeResource: didn't find pid %d for clientId %lld", pid, (long long) clientId);
- return;
+ return Status::ok();
}
ResourceInfos &infos = mMap.editValueAt(index);
index = infos.indexOfKey(clientId);
if (index < 0) {
ALOGV("removeResource: didn't find clientId %lld", (long long) clientId);
- return;
+ return Status::ok();
}
const ResourceInfo &info = infos[index];
@@ -417,45 +445,49 @@
IInterface::asBinder(info.client)->unlinkToDeath(info.deathNotifier);
infos.removeItemsAt(index);
+ return Status::ok();
}
void ResourceManagerService::getClientForResource_l(
- int callingPid, const MediaResource *res, Vector<sp<IResourceManagerClient>> *clients) {
+ int callingPid, const MediaResourceParcel *res, Vector<sp<IResourceManagerClient>> *clients) {
if (res == NULL) {
return;
}
sp<IResourceManagerClient> client;
- if (getLowestPriorityBiggestClient_l(callingPid, res->mType, &client)) {
+ if (getLowestPriorityBiggestClient_l(callingPid, res->type, &client)) {
clients->push_back(client);
}
}
-bool ResourceManagerService::reclaimResource(
- int callingPid, const Vector<MediaResource> &resources) {
+Status ResourceManagerService::reclaimResource(
+ int32_t callingPid,
+ const std::vector<MediaResourceParcel>& resources,
+ bool* _aidl_return) {
String8 log = String8::format("reclaimResource(callingPid %d, resources %s)",
callingPid, getString(resources).string());
mServiceLog->add(log);
+ *_aidl_return = false;
Vector<sp<IResourceManagerClient>> clients;
{
Mutex::Autolock lock(mLock);
if (!mProcessInfo->isValidPid(callingPid)) {
ALOGE("Rejected reclaimResource call with invalid callingPid.");
- return false;
+ return Status::fromServiceSpecificError(BAD_VALUE);
}
- const MediaResource *secureCodec = NULL;
- const MediaResource *nonSecureCodec = NULL;
- const MediaResource *graphicMemory = NULL;
- const MediaResource *drmSession = NULL;
+ const MediaResourceParcel *secureCodec = NULL;
+ const MediaResourceParcel *nonSecureCodec = NULL;
+ const MediaResourceParcel *graphicMemory = NULL;
+ const MediaResourceParcel *drmSession = NULL;
for (size_t i = 0; i < resources.size(); ++i) {
- MediaResource::Type type = resources[i].mType;
- if (resources[i].mType == MediaResource::kSecureCodec) {
+ MediaResource::Type type = resources[i].type;
+ if (resources[i].type == MediaResource::Type::kSecureCodec) {
secureCodec = &resources[i];
- } else if (type == MediaResource::kNonSecureCodec) {
+ } else if (type == MediaResource::Type::kNonSecureCodec) {
nonSecureCodec = &resources[i];
- } else if (type == MediaResource::kGraphicMemory) {
+ } else if (type == MediaResource::Type::kGraphicMemory) {
graphicMemory = &resources[i];
- } else if (type == MediaResource::kDrmSession) {
+ } else if (type == MediaResource::Type::kDrmSession) {
drmSession = &resources[i];
}
}
@@ -463,27 +495,27 @@
// first pass to handle secure/non-secure codec conflict
if (secureCodec != NULL) {
if (!mSupportsMultipleSecureCodecs) {
- if (!getAllClients_l(callingPid, MediaResource::kSecureCodec, &clients)) {
- return false;
+ if (!getAllClients_l(callingPid, MediaResource::Type::kSecureCodec, &clients)) {
+ return Status::ok();
}
}
if (!mSupportsSecureWithNonSecureCodec) {
- if (!getAllClients_l(callingPid, MediaResource::kNonSecureCodec, &clients)) {
- return false;
+ if (!getAllClients_l(callingPid, MediaResource::Type::kNonSecureCodec, &clients)) {
+ return Status::ok();
}
}
}
if (nonSecureCodec != NULL) {
if (!mSupportsSecureWithNonSecureCodec) {
- if (!getAllClients_l(callingPid, MediaResource::kSecureCodec, &clients)) {
- return false;
+ if (!getAllClients_l(callingPid, MediaResource::Type::kSecureCodec, &clients)) {
+ return Status::ok();
}
}
}
if (drmSession != NULL) {
getClientForResource_l(callingPid, drmSession, &clients);
if (clients.size() == 0) {
- return false;
+ return Status::ok();
}
}
@@ -501,32 +533,35 @@
if (clients.size() == 0) {
// if we are here, run the fourth pass to free one codec with the different type.
if (secureCodec != NULL) {
- MediaResource temp(MediaResource::kNonSecureCodec, 1);
+ MediaResource temp(MediaResource::Type::kNonSecureCodec, 1);
getClientForResource_l(callingPid, &temp, &clients);
}
if (nonSecureCodec != NULL) {
- MediaResource temp(MediaResource::kSecureCodec, 1);
+ MediaResource temp(MediaResource::Type::kSecureCodec, 1);
getClientForResource_l(callingPid, &temp, &clients);
}
}
}
if (clients.size() == 0) {
- return false;
+ return Status::ok();
}
sp<IResourceManagerClient> failedClient;
for (size_t i = 0; i < clients.size(); ++i) {
log = String8::format("reclaimResource from client %p", clients[i].get());
mServiceLog->add(log);
- if (!clients[i]->reclaimResource()) {
+ bool success;
+ Status status = clients[i]->reclaimResource(&success);
+ if (!status.isOk() || !success) {
failedClient = clients[i];
break;
}
}
if (failedClient == NULL) {
- return true;
+ *_aidl_return = true;
+ return Status::ok();
}
{
@@ -551,7 +586,7 @@
}
}
- return false;
+ return Status::ok();
}
bool ResourceManagerService::getAllClients_l(
@@ -666,10 +701,10 @@
for (size_t i = 0; i < infos.size(); ++i) {
const ResourceList &resources = infos[i].resources;
for (auto it = resources.begin(); it != resources.end(); it++) {
- const MediaResource &resource = it->second;
- if (resource.mType == type) {
- if (resource.mValue > largestValue) {
- largestValue = resource.mValue;
+ const MediaResourceParcel &resource = it->second;
+ if (resource.type == type) {
+ if (resource.value > largestValue) {
+ largestValue = resource.value;
clientTemp = infos[i].client;
}
}
@@ -685,4 +720,5 @@
return true;
}
+} // namespace media
} // namespace android
diff --git a/services/mediaresourcemanager/ResourceManagerService.h b/services/mediaresourcemanager/ResourceManagerService.h
index 44d0c28..b5b9f86 100644
--- a/services/mediaresourcemanager/ResourceManagerService.h
+++ b/services/mediaresourcemanager/ResourceManagerService.h
@@ -15,25 +15,32 @@
** limitations under the License.
*/
-#ifndef ANDROID_RESOURCEMANAGERSERVICE_H
-#define ANDROID_RESOURCEMANAGERSERVICE_H
+#ifndef ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H
+#define ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H
+#include <android/media/BnResourceManagerService.h>
#include <arpa/inet.h>
#include <binder/BinderService.h>
+#include <media/MediaResource.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/String8.h>
#include <utils/threads.h>
#include <utils/Vector.h>
-#include <media/IResourceManagerService.h>
-
namespace android {
class ServiceLog;
struct ProcessInfoInterface;
-typedef std::map<std::tuple<MediaResource::Type, MediaResource::SubType, std::vector<uint8_t>>, MediaResource> ResourceList;
+namespace media {
+
+using android::binder::Status;
+
+typedef std::map<std::tuple<
+ MediaResource::Type, MediaResource::SubType, std::vector<uint8_t>>,
+ MediaResourceParcel> ResourceList;
+
struct ResourceInfo {
int64_t clientId;
uid_t uid;
@@ -69,26 +76,31 @@
const sp<SystemCallbackInterface> &systemResource);
// IResourceManagerService interface
- virtual void config(const Vector<MediaResourcePolicy> &policies);
+ Status config(const std::vector<MediaResourcePolicyParcel>& policies) override;
- virtual void addResource(
- int pid,
- int uid,
+ Status addResource(
+ int32_t pid,
+ int32_t uid,
int64_t clientId,
- const sp<IResourceManagerClient> client,
- const Vector<MediaResource> &resources);
+ const sp<IResourceManagerClient>& client,
+ const std::vector<MediaResourceParcel>& resources) override;
- virtual void removeResource(int pid, int64_t clientId,
- const Vector<MediaResource> &resources);
+ Status removeResource(
+ int32_t pid,
+ int64_t clientId,
+ const std::vector<MediaResourceParcel>& resources) override;
- virtual void removeClient(int pid, int64_t clientId);
+ Status removeClient(int32_t pid, int64_t clientId) override;
// Tries to reclaim resource from processes with lower priority than the calling process
// according to the requested resources.
// Returns true if any resource has been reclaimed, otherwise returns false.
- virtual bool reclaimResource(int callingPid, const Vector<MediaResource> &resources);
+ Status reclaimResource(
+ int32_t callingPid,
+ const std::vector<MediaResourceParcel>& resources,
+ bool* _aidl_return) override;
- void removeResource(int pid, int64_t clientId, bool checkValid);
+ Status removeResource(int pid, int64_t clientId, bool checkValid);
protected:
virtual ~ResourceManagerService();
@@ -120,14 +132,14 @@
// A helper function basically calls getLowestPriorityBiggestClient_l and add the result client
// to the given Vector.
- void getClientForResource_l(
- int callingPid, const MediaResource *res, Vector<sp<IResourceManagerClient>> *clients);
+ void getClientForResource_l(int callingPid,
+ const MediaResourceParcel *res, Vector<sp<IResourceManagerClient>> *clients);
- void onFirstAdded(const MediaResource& res, const ResourceInfo& clientInfo);
- void onLastRemoved(const MediaResource& res, const ResourceInfo& clientInfo);
+ void onFirstAdded(const MediaResourceParcel& res, const ResourceInfo& clientInfo);
+ void onLastRemoved(const MediaResourceParcel& res, const ResourceInfo& clientInfo);
// Merge r2 into r1
- void mergeResources(MediaResource& r1, const MediaResource& r2);
+ void mergeResources(MediaResourceParcel& r1, const MediaResourceParcel& r2);
mutable Mutex mLock;
sp<ProcessInfoInterface> mProcessInfo;
@@ -140,7 +152,7 @@
};
// ----------------------------------------------------------------------------
+} // namespace media
+} // namespace android
-}; // namespace android
-
-#endif // ANDROID_RESOURCEMANAGERSERVICE_H
+#endif // ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H
diff --git a/services/mediaresourcemanager/test/ResourceManagerService_test.cpp b/services/mediaresourcemanager/test/ResourceManagerService_test.cpp
index 9e14151..203baf5 100644
--- a/services/mediaresourcemanager/test/ResourceManagerService_test.cpp
+++ b/services/mediaresourcemanager/test/ResourceManagerService_test.cpp
@@ -21,13 +21,16 @@
#include <gtest/gtest.h>
#include "ResourceManagerService.h"
-#include <media/IResourceManagerService.h>
+#include <android/media/BnResourceManagerClient.h>
#include <media/MediaResource.h>
#include <media/MediaResourcePolicy.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/ProcessInfoInterface.h>
namespace android {
+namespace media {
+
+using ::android::binder::Status;
static int64_t getId(const sp<IResourceManagerClient>& client) {
return (int64_t) client.get();
@@ -112,15 +115,17 @@
TestClient(int pid, sp<ResourceManagerService> service)
: mReclaimed(false), mPid(pid), mService(service) {}
- virtual bool reclaimResource() {
+ Status reclaimResource(bool* _aidl_return) override {
sp<IResourceManagerClient> client(this);
mService->removeClient(mPid, (int64_t) client.get());
mReclaimed = true;
- return true;
+ *_aidl_return = true;
+ return Status::ok();
}
- virtual String8 getName() {
- return String8("test_client");
+ Status getName(::std::string* _aidl_return) override {
+ *_aidl_return = "test_client";
+ return Status::ok();
}
bool reclaimed() const {
@@ -157,6 +162,12 @@
return lhs.type == rhs.type && lhs.arg == rhs.arg;
}
+#define CHECK_STATUS_TRUE(condition) \
+ EXPECT_TRUE((condition).isOk() && (result))
+
+#define CHECK_STATUS_FALSE(condition) \
+ EXPECT_TRUE((condition).isOk() && !(result))
+
class ResourceManagerServiceTest : public ::testing::Test {
public:
ResourceManagerServiceTest()
@@ -168,13 +179,13 @@
}
protected:
- static bool isEqualResources(const Vector<MediaResource> &resources1,
+ static bool isEqualResources(const std::vector<MediaResourceParcel> &resources1,
const ResourceList &resources2) {
// convert resource1 to ResourceList
ResourceList r1;
for (size_t i = 0; i < resources1.size(); ++i) {
const auto &res = resources1[i];
- const auto resType = std::tuple(res.mType, res.mSubType, res.mId);
+ const auto resType = std::tuple(res.type, res.subType, res.id);
r1[resType] = res;
}
return r1 == resources2;
@@ -183,7 +194,7 @@
static void expectEqResourceInfo(const ResourceInfo &info,
int uid,
sp<IResourceManagerClient> client,
- const Vector<MediaResource> &resources) {
+ const std::vector<MediaResourceParcel> &resources) {
EXPECT_EQ(uid, info.uid);
EXPECT_EQ(client, info.client);
EXPECT_TRUE(isEqualResources(resources, info.resources));
@@ -219,25 +230,25 @@
// ---------------------------------------------------------------------------------
void addResource() {
// kTestPid1 mTestClient1
- Vector<MediaResource> resources1;
- resources1.push_back(MediaResource(MediaResource::kSecureCodec, 1));
+ std::vector<MediaResourceParcel> resources1;
+ resources1.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
- resources1.push_back(MediaResource(MediaResource::kGraphicMemory, 200));
- Vector<MediaResource> resources11;
- resources11.push_back(MediaResource(MediaResource::kGraphicMemory, 200));
+ resources1.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 200));
+ std::vector<MediaResourceParcel> resources11;
+ resources11.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 200));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources11);
// kTestPid2 mTestClient2
- Vector<MediaResource> resources2;
- resources2.push_back(MediaResource(MediaResource::kNonSecureCodec, 1));
- resources2.push_back(MediaResource(MediaResource::kGraphicMemory, 300));
+ std::vector<MediaResourceParcel> resources2;
+ resources2.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
+ resources2.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 300));
mService->addResource(kTestPid2, kTestUid2, getId(mTestClient2), mTestClient2, resources2);
// kTestPid2 mTestClient3
- Vector<MediaResource> resources3;
+ std::vector<MediaResourceParcel> resources3;
mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources3);
- resources3.push_back(MediaResource(MediaResource::kSecureCodec, 1));
- resources3.push_back(MediaResource(MediaResource::kGraphicMemory, 100));
+ resources3.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
+ resources3.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 100));
mService->addResource(kTestPid2, kTestUid2, getId(mTestClient3), mTestClient3, resources3);
const PidResourceInfosMap &map = mService->mMap;
@@ -256,32 +267,92 @@
expectEqResourceInfo(infos2.valueFor(getId(mTestClient3)), kTestUid2, mTestClient3, resources3);
}
+ void testCombineResourceWithNegativeValues() {
+ // kTestPid1 mTestClient1
+ std::vector<MediaResourceParcel> resources1;
+ resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, -100));
+ resources1.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, -100));
+ mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
+
+ // Expected result:
+ // 1) the client should have been added;
+ // 2) both resource entries should have been rejected, resource list should be empty.
+ const PidResourceInfosMap &map = mService->mMap;
+ EXPECT_EQ(1u, map.size());
+ ssize_t index1 = map.indexOfKey(kTestPid1);
+ ASSERT_GE(index1, 0);
+ const ResourceInfos &infos1 = map[index1];
+ EXPECT_EQ(1u, infos1.size());
+ std::vector<MediaResourceParcel> expected;
+ expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
+
+ resources1.clear();
+ resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, INT64_MAX));
+ resources1.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MAX));
+ mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
+ resources1.clear();
+ resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, 10));
+ resources1.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 10));
+ mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
+
+ // Expected result:
+ // Both values should saturate to INT64_MAX
+ expected.push_back(MediaResource(MediaResource::Type::kDrmSession, INT64_MAX));
+ expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MAX));
+ expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
+
+ resources1.clear();
+ resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, -10));
+ resources1.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, -10));
+ mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
+
+ // Expected result:
+ // 1) DrmSession resource should allow negative value addition, and value should drop accordingly
+ // 2) Non-drm session resource should ignore negative value addition.
+ expected.push_back(MediaResource(MediaResource::Type::kDrmSession, INT64_MAX - 10));
+ expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MAX));
+ expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
+
+ resources1.clear();
+ resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, INT64_MIN));
+ expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MIN));
+ mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
+
+ // Expected result:
+ // 1) DrmSession resource value should drop to 0, but the entry shouldn't be removed.
+ // 2) Non-drm session resource should ignore negative value addition.
+ expected.clear();
+ expected.push_back(MediaResource(MediaResource::Type::kDrmSession, 0));
+ expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MAX));
+ expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
+ }
+
void testConfig() {
EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs);
EXPECT_TRUE(mService->mSupportsSecureWithNonSecureCodec);
- Vector<MediaResourcePolicy> policies1;
+ std::vector<MediaResourcePolicyParcel> policies1;
policies1.push_back(
MediaResourcePolicy(
- String8(kPolicySupportsMultipleSecureCodecs),
- String8("true")));
+ IResourceManagerService::kPolicySupportsMultipleSecureCodecs(),
+ "true"));
policies1.push_back(
MediaResourcePolicy(
- String8(kPolicySupportsSecureWithNonSecureCodec),
- String8("false")));
+ IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec(),
+ "false"));
mService->config(policies1);
EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs);
EXPECT_FALSE(mService->mSupportsSecureWithNonSecureCodec);
- Vector<MediaResourcePolicy> policies2;
+ std::vector<MediaResourcePolicyParcel> policies2;
policies2.push_back(
MediaResourcePolicy(
- String8(kPolicySupportsMultipleSecureCodecs),
- String8("false")));
+ IResourceManagerService::kPolicySupportsMultipleSecureCodecs(),
+ "false"));
policies2.push_back(
MediaResourcePolicy(
- String8(kPolicySupportsSecureWithNonSecureCodec),
- String8("true")));
+ IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec(),
+ "true"));
mService->config(policies2);
EXPECT_FALSE(mService->mSupportsMultipleSecureCodecs);
EXPECT_TRUE(mService->mSupportsSecureWithNonSecureCodec);
@@ -289,12 +360,12 @@
void testCombineResource() {
// kTestPid1 mTestClient1
- Vector<MediaResource> resources1;
- resources1.push_back(MediaResource(MediaResource::kSecureCodec, 1));
+ std::vector<MediaResourceParcel> resources1;
+ resources1.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
- Vector<MediaResource> resources11;
- resources11.push_back(MediaResource(MediaResource::kGraphicMemory, 200));
+ std::vector<MediaResourceParcel> resources11;
+ resources11.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 200));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources11);
const PidResourceInfosMap &map = mService->mMap;
@@ -305,35 +376,35 @@
EXPECT_EQ(1u, infos1.size());
// test adding existing types to combine values
- resources1.push_back(MediaResource(MediaResource::kGraphicMemory, 100));
+ resources1.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 100));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
- Vector<MediaResource> expected;
- expected.push_back(MediaResource(MediaResource::kSecureCodec, 2));
- expected.push_back(MediaResource(MediaResource::kGraphicMemory, 300));
+ std::vector<MediaResourceParcel> expected;
+ expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, 2));
+ expected.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 300));
expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
// test adding new types (including types that differs only in subType)
- resources11.push_back(MediaResource(MediaResource::kNonSecureCodec, 1));
- resources11.push_back(MediaResource(MediaResource::kSecureCodec, MediaResource::kVideoCodec, 1));
+ resources11.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
+ resources11.push_back(MediaResource(MediaResource::Type::kSecureCodec, MediaResource::SubType::kVideoCodec, 1));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources11);
expected.clear();
- expected.push_back(MediaResource(MediaResource::kSecureCodec, 2));
- expected.push_back(MediaResource(MediaResource::kNonSecureCodec, 1));
- expected.push_back(MediaResource(MediaResource::kSecureCodec, MediaResource::kVideoCodec, 1));
- expected.push_back(MediaResource(MediaResource::kGraphicMemory, 500));
+ expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, 2));
+ expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
+ expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, MediaResource::SubType::kVideoCodec, 1));
+ expected.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 500));
expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
}
void testRemoveResource() {
// kTestPid1 mTestClient1
- Vector<MediaResource> resources1;
- resources1.push_back(MediaResource(MediaResource::kSecureCodec, 1));
+ std::vector<MediaResourceParcel> resources1;
+ resources1.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
- Vector<MediaResource> resources11;
- resources11.push_back(MediaResource(MediaResource::kGraphicMemory, 200));
+ std::vector<MediaResourceParcel> resources11;
+ resources11.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 200));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources11);
const PidResourceInfosMap &map = mService->mMap;
@@ -344,20 +415,26 @@
EXPECT_EQ(1u, infos1.size());
// test partial removal
- resources11.editItemAt(0).mValue = 100;
+ resources11[0].value = 100;
mService->removeResource(kTestPid1, getId(mTestClient1), resources11);
- Vector<MediaResource> expected;
- expected.push_back(MediaResource(MediaResource::kSecureCodec, 1));
- expected.push_back(MediaResource(MediaResource::kGraphicMemory, 100));
+ std::vector<MediaResourceParcel> expected;
+ expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
+ expected.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 100));
+ expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
+
+ // test removal request with negative value, should be ignored
+ resources11[0].value = -10000;
+ mService->removeResource(kTestPid1, getId(mTestClient1), resources11);
+
expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
// test complete removal with overshoot value
- resources11.editItemAt(0).mValue = 1000;
+ resources11[0].value = 1000;
mService->removeResource(kTestPid1, getId(mTestClient1), resources11);
expected.clear();
- expected.push_back(MediaResource(MediaResource::kSecureCodec, 1));
+ expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
expectEqResourceInfo(infos1.valueFor(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
}
@@ -380,7 +457,7 @@
void testGetAllClients() {
addResource();
- MediaResource::Type type = MediaResource::kSecureCodec;
+ MediaResource::Type type = MediaResource::Type::kSecureCodec;
Vector<sp<IResourceManagerClient> > clients;
EXPECT_FALSE(mService->getAllClients_l(kLowPriorityPid, type, &clients));
// some higher priority process (e.g. kTestPid2) owns the resource, so getAllClients_l
@@ -395,9 +472,10 @@
}
void testReclaimResourceSecure() {
- Vector<MediaResource> resources;
- resources.push_back(MediaResource(MediaResource::kSecureCodec, 1));
- resources.push_back(MediaResource(MediaResource::kGraphicMemory, 150));
+ bool result;
+ std::vector<MediaResourceParcel> resources;
+ resources.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
+ resources.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 150));
// ### secure codec can't coexist and secure codec can coexist with non-secure codec ###
{
@@ -406,19 +484,19 @@
mService->mSupportsSecureWithNonSecureCodec = true;
// priority too low
- EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
- EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kLowPriorityPid, resources, &result));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kMidPriorityPid, resources, &result));
// reclaim all secure codecs
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(true /* c1 */, false /* c2 */, true /* c3 */);
// call again should reclaim one largest graphic memory from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
// nothing left
- EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kHighPriorityPid, resources, &result));
}
// ### secure codecs can't coexist and secure codec can't coexist with non-secure codec ###
@@ -428,15 +506,15 @@
mService->mSupportsSecureWithNonSecureCodec = false;
// priority too low
- EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
- EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kLowPriorityPid, resources, &result));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kMidPriorityPid, resources, &result));
// reclaim all secure and non-secure codecs
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(true /* c1 */, true /* c2 */, true /* c3 */);
// nothing left
- EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kHighPriorityPid, resources, &result));
}
@@ -447,23 +525,23 @@
mService->mSupportsSecureWithNonSecureCodec = false;
// priority too low
- EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
- EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kLowPriorityPid, resources, &result));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kMidPriorityPid, resources, &result));
// reclaim all non-secure codecs
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
// call again should reclaim one largest graphic memory from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
// call again should reclaim another largest graphic memory from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, false /* c2 */, true /* c3 */);
// nothing left
- EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kHighPriorityPid, resources, &result));
}
// ### secure codecs can coexist and secure codec can coexist with non-secure codec ###
@@ -473,22 +551,22 @@
mService->mSupportsSecureWithNonSecureCodec = true;
// priority too low
- EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kLowPriorityPid, resources, &result));
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
// one largest graphic memory from lowest process got reclaimed
verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
// call again should reclaim another graphic memory from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
// call again should reclaim another graphic memory from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, false /* c2 */, true /* c3 */);
// nothing left
- EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kHighPriorityPid, resources, &result));
}
// ### secure codecs can coexist and secure codec can coexist with non-secure codec ###
@@ -497,27 +575,28 @@
mService->mSupportsMultipleSecureCodecs = true;
mService->mSupportsSecureWithNonSecureCodec = true;
- Vector<MediaResource> resources;
- resources.push_back(MediaResource(MediaResource::kSecureCodec, 1));
+ std::vector<MediaResourceParcel> resources;
+ resources.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
// secure codec from lowest process got reclaimed
verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
// call again should reclaim another secure codec from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, false /* c2 */, true /* c3 */);
// no more secure codec, non-secure codec will be reclaimed.
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
}
}
void testReclaimResourceNonSecure() {
- Vector<MediaResource> resources;
- resources.push_back(MediaResource(MediaResource::kNonSecureCodec, 1));
- resources.push_back(MediaResource(MediaResource::kGraphicMemory, 150));
+ bool result;
+ std::vector<MediaResourceParcel> resources;
+ resources.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
+ resources.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 150));
// ### secure codec can't coexist with non-secure codec ###
{
@@ -525,19 +604,19 @@
mService->mSupportsSecureWithNonSecureCodec = false;
// priority too low
- EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
- EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kLowPriorityPid, resources, &result));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kMidPriorityPid, resources, &result));
// reclaim all secure codecs
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(true /* c1 */, false /* c2 */, true /* c3 */);
// call again should reclaim one graphic memory from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
// nothing left
- EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kHighPriorityPid, resources, &result));
}
@@ -547,22 +626,22 @@
mService->mSupportsSecureWithNonSecureCodec = true;
// priority too low
- EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kLowPriorityPid, resources, &result));
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
// one largest graphic memory from lowest process got reclaimed
verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
// call again should reclaim another graphic memory from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
// call again should reclaim another graphic memory from lowest process
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(false /* c1 */, false /* c2 */, true /* c3 */);
// nothing left
- EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_FALSE(mService->reclaimResource(kHighPriorityPid, resources, &result));
}
// ### secure codec can coexist with non-secure codec ###
@@ -570,15 +649,15 @@
addResource();
mService->mSupportsSecureWithNonSecureCodec = true;
- Vector<MediaResource> resources;
- resources.push_back(MediaResource(MediaResource::kNonSecureCodec, 1));
+ std::vector<MediaResourceParcel> resources;
+ resources.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
// one non secure codec from lowest process got reclaimed
verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
// no more non-secure codec, secure codec from lowest priority process will be reclaimed
- EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
+ CHECK_STATUS_TRUE(mService->reclaimResource(kHighPriorityPid, resources, &result));
verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
// clean up client 3 which still left
@@ -587,7 +666,7 @@
}
void testGetLowestPriorityBiggestClient() {
- MediaResource::Type type = MediaResource::kGraphicMemory;
+ MediaResource::Type type = MediaResource::Type::kGraphicMemory;
sp<IResourceManagerClient> client;
EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(kHighPriorityPid, type, &client));
@@ -596,8 +675,8 @@
EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(kLowPriorityPid, type, &client));
EXPECT_TRUE(mService->getLowestPriorityBiggestClient_l(kHighPriorityPid, type, &client));
- // kTestPid1 is the lowest priority process with MediaResource::kGraphicMemory.
- // mTestClient1 has the largest MediaResource::kGraphicMemory within kTestPid1.
+ // kTestPid1 is the lowest priority process with MediaResource::Type::kGraphicMemory.
+ // mTestClient1 has the largest MediaResource::Type::kGraphicMemory within kTestPid1.
EXPECT_EQ(mTestClient1, client);
}
@@ -606,7 +685,7 @@
int priority;
TestProcessInfo processInfo;
- MediaResource::Type type = MediaResource::kGraphicMemory;
+ MediaResource::Type type = MediaResource::Type::kGraphicMemory;
EXPECT_FALSE(mService->getLowestPriorityPid_l(type, &pid, &priority));
addResource();
@@ -617,7 +696,7 @@
processInfo.getPriority(kTestPid1, &priority1);
EXPECT_EQ(priority1, priority);
- type = MediaResource::kNonSecureCodec;
+ type = MediaResource::Type::kNonSecureCodec;
EXPECT_TRUE(mService->getLowestPriorityPid_l(type, &pid, &priority));
EXPECT_EQ(kTestPid2, pid);
int priority2;
@@ -626,7 +705,7 @@
}
void testGetBiggestClient() {
- MediaResource::Type type = MediaResource::kGraphicMemory;
+ MediaResource::Type type = MediaResource::Type::kGraphicMemory;
sp<IResourceManagerClient> client;
EXPECT_FALSE(mService->getBiggestClient_l(kTestPid2, type, &client));
@@ -648,8 +727,8 @@
EXPECT_EQ(EventType::VIDEO_RESET, mSystemCB->lastEventType());
// new client request should cause VIDEO_ON
- Vector<MediaResource> resources1;
- resources1.push_back(MediaResource(MediaResource::kBattery, MediaResource::kVideoCodec, 1));
+ std::vector<MediaResourceParcel> resources1;
+ resources1.push_back(MediaResource(MediaResource::Type::kBattery, MediaResource::SubType::kVideoCodec, 1));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
EXPECT_EQ(2u, mSystemCB->eventCount());
EXPECT_EQ(EventEntry({EventType::VIDEO_ON, kTestUid1}), mSystemCB->lastEvent());
@@ -659,8 +738,8 @@
EXPECT_EQ(2u, mSystemCB->eventCount());
// new client request should cause VIDEO_ON
- Vector<MediaResource> resources2;
- resources2.push_back(MediaResource(MediaResource::kBattery, MediaResource::kVideoCodec, 2));
+ std::vector<MediaResourceParcel> resources2;
+ resources2.push_back(MediaResource(MediaResource::Type::kBattery, MediaResource::SubType::kVideoCodec, 2));
mService->addResource(kTestPid2, kTestUid2, getId(mTestClient2), mTestClient2, resources2);
EXPECT_EQ(3u, mSystemCB->eventCount());
EXPECT_EQ(EventEntry({EventType::VIDEO_ON, kTestUid2}), mSystemCB->lastEvent());
@@ -687,8 +766,8 @@
EXPECT_EQ(EventType::VIDEO_RESET, mSystemCB->lastEventType());
// new client request should cause CPUSET_ENABLE
- Vector<MediaResource> resources1;
- resources1.push_back(MediaResource(MediaResource::kCpuBoost, 1));
+ std::vector<MediaResourceParcel> resources1;
+ resources1.push_back(MediaResource(MediaResource::Type::kCpuBoost, 1));
mService->addResource(kTestPid1, kTestUid1, getId(mTestClient1), mTestClient1, resources1);
EXPECT_EQ(2u, mSystemCB->eventCount());
EXPECT_EQ(EventType::CPUSET_ENABLE, mSystemCB->lastEventType());
@@ -698,8 +777,8 @@
EXPECT_EQ(2u, mSystemCB->eventCount());
// new client request should cause CPUSET_ENABLE
- Vector<MediaResource> resources2;
- resources2.push_back(MediaResource(MediaResource::kCpuBoost, 2));
+ std::vector<MediaResourceParcel> resources2;
+ resources2.push_back(MediaResource(MediaResource::Type::kCpuBoost, 2));
mService->addResource(kTestPid2, kTestUid2, getId(mTestClient2), mTestClient2, resources2);
EXPECT_EQ(3u, mSystemCB->eventCount());
EXPECT_EQ(EventType::CPUSET_ENABLE, mSystemCB->lastEventType());
@@ -738,6 +817,10 @@
testCombineResource();
}
+TEST_F(ResourceManagerServiceTest, combineResourceNegative) {
+ testCombineResourceWithNegativeValues();
+}
+
TEST_F(ResourceManagerServiceTest, removeResource) {
testRemoveResource();
}
@@ -779,4 +862,5 @@
testCpusetBoost();
}
+} // namespace media
} // namespace android