Merge "Merge "directly call data loader manager service from incremental... (2de19dd4) · Commits · e / os / android_frameworks_base

services/incremental/IncrementalService.cpp

+17 −19

Original line number	Original line	Diff line number	Diff line
	@@ -155,7 +155,7 @@ std::string makeBindMdName() {
	} // namespace		} // namespace

	IncrementalService::IncFsMount::~IncFsMount() {		IncrementalService::IncFsMount::~IncFsMount() {
	incrementalService.mIncrementalManager->destroyDataLoader(mountId);		incrementalService.mDataLoaderManager->destroyDataLoader(mountId);
	control.reset();		control.reset();
	LOG(INFO) << "Unmounting and cleaning up mount " << mountId << " with root '" << root << '\'';		LOG(INFO) << "Unmounting and cleaning up mount " << mountId << " with root '" << root << '\'';
	for (auto&& [target, _] : bindPoints) {		for (auto&& [target, _] : bindPoints) {
	@@ -229,14 +229,14 @@ void IncrementalService::IncFsMount::cleanupFilesystem(std::string_view root) {

	IncrementalService::IncrementalService(ServiceManagerWrapper&& sm, std::string_view rootDir)		IncrementalService::IncrementalService(ServiceManagerWrapper&& sm, std::string_view rootDir)
	: mVold(sm.getVoldService()),		: mVold(sm.getVoldService()),
	mIncrementalManager(sm.getIncrementalManager()),		mDataLoaderManager(sm.getDataLoaderManager()),
	mIncFs(sm.getIncFs()),		mIncFs(sm.getIncFs()),
	mIncrementalDir(rootDir) {		mIncrementalDir(rootDir) {
	if (!mVold) {		if (!mVold) {
	LOG(FATAL) << "Vold service is unavailable";		LOG(FATAL) << "Vold service is unavailable";
	}		}
	if (!mIncrementalManager) {		if (!mDataLoaderManager) {
	LOG(FATAL) << "IncrementalManager service is unavailable";		LOG(FATAL) << "DataLoaderManagerService is unavailable";
	}		}
	mountExistingImages();		mountExistingImages();
	}		}
	@@ -921,7 +921,6 @@ bool IncrementalService::startLoading(StorageId storage) const {
	if (!ifs) {		if (!ifs) {
	return false;		return false;
	}		}
	bool started = false;
	std::unique_lock l(ifs->lock);		std::unique_lock l(ifs->lock);
	if (ifs->dataLoaderStatus != IDataLoaderStatusListener::DATA_LOADER_CREATED) {		if (ifs->dataLoaderStatus != IDataLoaderStatusListener::DATA_LOADER_CREATED) {
	if (ifs->dataLoaderReady.wait_for(l, Seconds(5)) == std::cv_status::timeout) {		if (ifs->dataLoaderReady.wait_for(l, Seconds(5)) == std::cv_status::timeout) {
	@@ -929,11 +928,19 @@ bool IncrementalService::startLoading(StorageId storage) const {
	return false;		return false;
	}		}
	}		}
	auto status = mIncrementalManager->startDataLoader(ifs->mountId, &started);		sp<IDataLoader> dataloader;
			auto status = mDataLoaderManager->getDataLoader(ifs->mountId, &dataloader);
	if (!status.isOk()) {		if (!status.isOk()) {
	return false;		return false;
	}		}
	return started;		if (!dataloader) {
			return false;
			}
			status = dataloader->start();
			if (!status.isOk()) {
			return false;
			}
			return true;
	}		}

	void IncrementalService::mountExistingImages() {		void IncrementalService::mountExistingImages() {
	@@ -1086,7 +1093,7 @@ bool IncrementalService::prepareDataLoader(IncrementalService::IncFsMount& ifs,
	sp<IncrementalDataLoaderListener> listener =		sp<IncrementalDataLoaderListener> listener =
	new IncrementalDataLoaderListener(this, externalListener);		new IncrementalDataLoaderListener(this, externalListener);
	bool created = false;		bool created = false;
	auto status = mIncrementalManager->prepareDataLoader(ifs.mountId, fsControlParcel, *dlp,		auto status = mDataLoaderManager->initializeDataLoader(ifs.mountId, *dlp, fsControlParcel,
	listener, &created);		listener, &created);
	if (!status.isOk() \|\| !created) {		if (!status.isOk() \|\| !created) {
	LOG(ERROR) << "Failed to create a data loader for mount " << ifs.mountId;		LOG(ERROR) << "Failed to create a data loader for mount " << ifs.mountId;
	@@ -1229,16 +1236,7 @@ binder::Status IncrementalService::IncrementalDataLoaderListener::onStatusChange
	ifs->dataLoaderStatus = newStatus;		ifs->dataLoaderStatus = newStatus;
	switch (newStatus) {		switch (newStatus) {
	case IDataLoaderStatusListener::DATA_LOADER_NO_CONNECTION: {		case IDataLoaderStatusListener::DATA_LOADER_NO_CONNECTION: {
	auto now = Clock::now();		// TODO(b/150411019): handle data loader connection loss
	if (ifs->connectionLostTime.time_since_epoch().count() == 0) {
	ifs->connectionLostTime = now;
	break;
	}
	auto duration =
	std::chrono::duration_cast<Seconds>(now - ifs->connectionLostTime).count();
	if (duration >= 10) {
	incrementalService.mIncrementalManager->showHealthBlockedUI(mountId);
	}
	break;		break;
	}		}
	case IDataLoaderStatusListener::DATA_LOADER_CONNECTION_OK: {		case IDataLoaderStatusListener::DATA_LOADER_CONNECTION_OK: {

services/incremental/IncrementalService.h

+1 −2

Original line number	Original line	Diff line number	Diff line
	@@ -19,7 +19,6 @@
	#include <android-base/strings.h>		#include <android-base/strings.h>
	#include <android-base/unique_fd.h>		#include <android-base/unique_fd.h>
	#include <android/content/pm/DataLoaderParamsParcel.h>		#include <android/content/pm/DataLoaderParamsParcel.h>
	#include <android/os/incremental/IIncrementalManager.h>
	#include <binder/IServiceManager.h>		#include <binder/IServiceManager.h>
	#include <utils/String16.h>		#include <utils/String16.h>
	#include <utils/StrongPointer.h>		#include <utils/StrongPointer.h>
	@@ -220,7 +219,7 @@ private:

	// Member variables		// Member variables
	std::unique_ptr<VoldServiceWrapper> mVold;		std::unique_ptr<VoldServiceWrapper> mVold;
	std::unique_ptr<IncrementalManagerWrapper> mIncrementalManager;		std::unique_ptr<DataLoaderManagerWrapper> mDataLoaderManager;
	std::unique_ptr<IncFsWrapper> mIncFs;		std::unique_ptr<IncFsWrapper> mIncFs;
	const std::string mIncrementalDir;		const std::string mIncrementalDir;

services/incremental/ServiceWrappers.cpp

+5 −5

Original line number	Original line	Diff line number	Diff line
	@@ -23,7 +23,7 @@ using namespace std::literals;
	namespace android::os::incremental {		namespace android::os::incremental {

	static constexpr auto kVoldServiceName = "vold"sv;		static constexpr auto kVoldServiceName = "vold"sv;
	static constexpr auto kIncrementalManagerName = "incremental"sv;		static constexpr auto kDataLoaderManagerName = "dataloader_manager"sv;

	RealServiceManager::RealServiceManager(sp<IServiceManager> serviceManager)		RealServiceManager::RealServiceManager(sp<IServiceManager> serviceManager)
	: mServiceManager(std::move(serviceManager)) {}		: mServiceManager(std::move(serviceManager)) {}
	@@ -46,11 +46,11 @@ std::unique_ptr<VoldServiceWrapper> RealServiceManager::getVoldService() {
	return nullptr;		return nullptr;
	}		}

	std::unique_ptr<IncrementalManagerWrapper> RealServiceManager::getIncrementalManager() {		std::unique_ptr<DataLoaderManagerWrapper> RealServiceManager::getDataLoaderManager() {
	sp<IIncrementalManager> manager =		sp<IDataLoaderManager> manager =
	RealServiceManager::getRealService<IIncrementalManager>(kIncrementalManagerName);		RealServiceManager::getRealService<IDataLoaderManager>(kDataLoaderManagerName);
	if (manager) {		if (manager) {
	return std::make_unique<RealIncrementalManager>(manager);		return std::make_unique<RealDataLoaderManager>(manager);
	}		}
	return nullptr;		return nullptr;
	}		}

services/incremental/ServiceWrappers.h

+23 −26

Original line number	Original line	Diff line number	Diff line
	@@ -20,9 +20,10 @@
	#include <android-base/unique_fd.h>		#include <android-base/unique_fd.h>
	#include <android/content/pm/DataLoaderParamsParcel.h>		#include <android/content/pm/DataLoaderParamsParcel.h>
	#include <android/content/pm/FileSystemControlParcel.h>		#include <android/content/pm/FileSystemControlParcel.h>
			#include <android/content/pm/IDataLoader.h>
			#include <android/content/pm/IDataLoaderManager.h>
	#include <android/content/pm/IDataLoaderStatusListener.h>		#include <android/content/pm/IDataLoaderStatusListener.h>
	#include <android/os/IVold.h>		#include <android/os/IVold.h>
	#include <android/os/incremental/IIncrementalManager.h>
	#include <binder/IServiceManager.h>		#include <binder/IServiceManager.h>
	#include <incfs.h>		#include <incfs.h>

	@@ -50,17 +51,16 @@ public:
	const std::string& targetDir) const = 0;		const std::string& targetDir) const = 0;
	};		};

	class IncrementalManagerWrapper {		class DataLoaderManagerWrapper {
	public:		public:
	virtual ~IncrementalManagerWrapper() = default;		virtual ~DataLoaderManagerWrapper() = default;
	virtual binder::Status prepareDataLoader(MountId mountId,		virtual binder::Status initializeDataLoader(MountId mountId,
	const FileSystemControlParcel& control,
	const DataLoaderParamsParcel& params,		const DataLoaderParamsParcel& params,
			const FileSystemControlParcel& control,
	const sp<IDataLoaderStatusListener>& listener,		const sp<IDataLoaderStatusListener>& listener,
	bool* _aidl_return) const = 0;		bool* _aidl_return) const = 0;
	virtual binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const = 0;		virtual binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const = 0;
	virtual binder::Status destroyDataLoader(MountId mountId) const = 0;		virtual binder::Status destroyDataLoader(MountId mountId) const = 0;
	virtual binder::Status showHealthBlockedUI(MountId mountId) const = 0;
	};		};

	class IncFsWrapper {		class IncFsWrapper {
	@@ -82,7 +82,7 @@ class ServiceManagerWrapper {
	public:		public:
	virtual ~ServiceManagerWrapper() = default;		virtual ~ServiceManagerWrapper() = default;
	virtual std::unique_ptr<VoldServiceWrapper> getVoldService() = 0;		virtual std::unique_ptr<VoldServiceWrapper> getVoldService() = 0;
	virtual std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() = 0;		virtual std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() = 0;
	virtual std::unique_ptr<IncFsWrapper> getIncFs() = 0;		virtual std::unique_ptr<IncFsWrapper> getIncFs() = 0;
	};		};

	@@ -109,29 +109,26 @@ private:
	sp<os::IVold> mInterface;		sp<os::IVold> mInterface;
	};		};

	class RealIncrementalManager : public IncrementalManagerWrapper {		class RealDataLoaderManager : public DataLoaderManagerWrapper {
	public:		public:
	RealIncrementalManager(const sp<os::incremental::IIncrementalManager> manager)		RealDataLoaderManager(const sp<content::pm::IDataLoaderManager> manager)
	: mInterface(manager) {}		: mInterface(manager) {}
	~RealIncrementalManager() = default;		~RealDataLoaderManager() = default;
	binder::Status prepareDataLoader(MountId mountId, const FileSystemControlParcel& control,		binder::Status initializeDataLoader(MountId mountId, const DataLoaderParamsParcel& params,
	const DataLoaderParamsParcel& params,		const FileSystemControlParcel& control,
	const sp<IDataLoaderStatusListener>& listener,		const sp<IDataLoaderStatusListener>& listener,
	bool* _aidl_return) const override {		bool* _aidl_return) const override {
	return mInterface->prepareDataLoader(mountId, control, params, listener, _aidl_return);		return mInterface->initializeDataLoader(mountId, params, control, listener, _aidl_return);
	}		}
	binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const override {		binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const override {
	return mInterface->startDataLoader(mountId, _aidl_return);		return mInterface->getDataLoader(mountId, _aidl_return);
	}		}
	binder::Status destroyDataLoader(MountId mountId) const override {		binder::Status destroyDataLoader(MountId mountId) const override {
	return mInterface->destroyDataLoader(mountId);		return mInterface->destroyDataLoader(mountId);
	}		}
	binder::Status showHealthBlockedUI(MountId mountId) const override {
	return mInterface->showHealthBlockedUI(mountId);
	}

	private:		private:
	sp<os::incremental::IIncrementalManager> mInterface;		sp<content::pm::IDataLoaderManager> mInterface;
	};		};

	class RealServiceManager : public ServiceManagerWrapper {		class RealServiceManager : public ServiceManagerWrapper {
	@@ -139,7 +136,7 @@ public:
	RealServiceManager(sp<IServiceManager> serviceManager);		RealServiceManager(sp<IServiceManager> serviceManager);
	~RealServiceManager() = default;		~RealServiceManager() = default;
	std::unique_ptr<VoldServiceWrapper> getVoldService() override;		std::unique_ptr<VoldServiceWrapper> getVoldService() override;
	std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() override;		std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() override;
	std::unique_ptr<IncFsWrapper> getIncFs() override;		std::unique_ptr<IncFsWrapper> getIncFs() override;

	private:		private:

services/incremental/test/IncrementalServiceTest.cpp

+68 −54

Original line number	Original line	Diff line number	Diff line
	@@ -93,22 +93,35 @@ private:
	TemporaryFile logFile;		TemporaryFile logFile;
	};		};

	class MockIncrementalManager : public IncrementalManagerWrapper {		class FakeDataLoader : public IDataLoader {
	public:		public:
	MOCK_CONST_METHOD5(prepareDataLoader,		IBinder* onAsBinder() override { return nullptr; }
	binder::Status(int32_t mountId, const FileSystemControlParcel& control,		binder::Status create(int32_t, const DataLoaderParamsParcel&, const FileSystemControlParcel&,
	const DataLoaderParamsParcel& params,		const sp<IDataLoaderStatusListener>&) override {
			return binder::Status::ok();
			}
			binder::Status start() override { return binder::Status::ok(); }
			binder::Status stop() override { return binder::Status::ok(); }
			binder::Status destroy() override { return binder::Status::ok(); }
			binder::Status prepareImage(const std::vector<InstallationFileParcel>&,
			const std::vector<std::string>&) override {
			return binder::Status::ok();
			}
			};

			class MockDataLoaderManager : public DataLoaderManagerWrapper {
			public:
			MOCK_CONST_METHOD5(initializeDataLoader,
			binder::Status(int32_t mountId, const DataLoaderParamsParcel& params,
			const FileSystemControlParcel& control,
	const sp<IDataLoaderStatusListener>& listener,		const sp<IDataLoaderStatusListener>& listener,
	bool* _aidl_return));		bool* _aidl_return));
	MOCK_CONST_METHOD2(startDataLoader, binder::Status(int32_t mountId, bool* _aidl_return));		MOCK_CONST_METHOD2(getDataLoader,
			binder::Status(int32_t mountId, sp<IDataLoader>* _aidl_return));
	MOCK_CONST_METHOD1(destroyDataLoader, binder::Status(int32_t mountId));		MOCK_CONST_METHOD1(destroyDataLoader, binder::Status(int32_t mountId));
	MOCK_CONST_METHOD3(newFileForDataLoader,
	binder::Status(int32_t mountId, FileId fileId,
	const ::std::vector<uint8_t>& metadata));
	MOCK_CONST_METHOD1(showHealthBlockedUI, binder::Status(int32_t mountId));

	binder::Status prepareDataLoaderOk(int32_t mountId, const FileSystemControlParcel& control,		binder::Status initializeDataLoaderOk(int32_t mountId, const DataLoaderParamsParcel& params,
	const DataLoaderParamsParcel& params,		const FileSystemControlParcel& control,
	const sp<IDataLoaderStatusListener>& listener,		const sp<IDataLoaderStatusListener>& listener,
	bool* _aidl_return) {		bool* _aidl_return) {
	mId = mountId;		mId = mountId;
	@@ -117,23 +130,23 @@ public:
	return binder::Status::ok();		return binder::Status::ok();
	}		}

	binder::Status startDataLoaderOk(int32_t mountId, bool* _aidl_return) {		binder::Status getDataLoaderOk(int32_t mountId, sp<IDataLoader>* _aidl_return) {
	*_aidl_return = true;		*_aidl_return = mDataLoader;
	return binder::Status::ok();		return binder::Status::ok();
	}		}

	void prepareDataLoaderFails() {		void initializeDataLoaderFails() {
	ON_CALL(*this, prepareDataLoader(_, _, _, _, _))		ON_CALL(*this, initializeDataLoader(_, _, _, _, _))
	.WillByDefault(Return(		.WillByDefault(Return(
	(binder::Status::fromExceptionCode(1, String8("failed to prepare")))));		(binder::Status::fromExceptionCode(1, String8("failed to prepare")))));
	}		}
	void prepareDataLoaderSuccess() {		void initializeDataLoaderSuccess() {
	ON_CALL(*this, prepareDataLoader(_, _, _, _, _))		ON_CALL(*this, initializeDataLoader(_, _, _, _, _))
	.WillByDefault(Invoke(this, &MockIncrementalManager::prepareDataLoaderOk));		.WillByDefault(Invoke(this, &MockDataLoaderManager::initializeDataLoaderOk));
	}		}
	void startDataLoaderSuccess() {		void getDataLoaderSuccess() {
	ON_CALL(*this, startDataLoader(_, _))		ON_CALL(*this, getDataLoader(_, _))
	.WillByDefault(Invoke(this, &MockIncrementalManager::startDataLoaderOk));		.WillByDefault(Invoke(this, &MockDataLoaderManager::getDataLoaderOk));
	}		}
	void setDataLoaderStatusNotReady() {		void setDataLoaderStatusNotReady() {
	mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_DESTROYED);		mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_DESTROYED);
	@@ -145,6 +158,7 @@ public:
	private:		private:
	int mId;		int mId;
	sp<IDataLoaderStatusListener> mListener;		sp<IDataLoaderStatusListener> mListener;
			sp<IDataLoader> mDataLoader = sp<IDataLoader>(new FakeDataLoader());
	};		};

	class MockIncFs : public IncFsWrapper {		class MockIncFs : public IncFsWrapper {
	@@ -197,20 +211,20 @@ public:
	class MockServiceManager : public ServiceManagerWrapper {		class MockServiceManager : public ServiceManagerWrapper {
	public:		public:
	MockServiceManager(std::unique_ptr<MockVoldService> vold,		MockServiceManager(std::unique_ptr<MockVoldService> vold,
	std::unique_ptr<MockIncrementalManager> manager,		std::unique_ptr<MockDataLoaderManager> manager,
	std::unique_ptr<MockIncFs> incfs)		std::unique_ptr<MockIncFs> incfs)
	: mVold(std::move(vold)),		: mVold(std::move(vold)),
	mIncrementalManager(std::move(manager)),		mDataLoaderManager(std::move(manager)),
	mIncFs(std::move(incfs)) {}		mIncFs(std::move(incfs)) {}
	std::unique_ptr<VoldServiceWrapper> getVoldService() final { return std::move(mVold); }		std::unique_ptr<VoldServiceWrapper> getVoldService() final { return std::move(mVold); }
	std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() final {		std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() final {
	return std::move(mIncrementalManager);		return std::move(mDataLoaderManager);
	}		}
	std::unique_ptr<IncFsWrapper> getIncFs() final { return std::move(mIncFs); }		std::unique_ptr<IncFsWrapper> getIncFs() final { return std::move(mIncFs); }

	private:		private:
	std::unique_ptr<MockVoldService> mVold;		std::unique_ptr<MockVoldService> mVold;
	std::unique_ptr<MockIncrementalManager> mIncrementalManager;		std::unique_ptr<MockDataLoaderManager> mDataLoaderManager;
	std::unique_ptr<MockIncFs> mIncFs;		std::unique_ptr<MockIncFs> mIncFs;
	};		};

	@@ -221,14 +235,14 @@ public:
	void SetUp() override {		void SetUp() override {
	auto vold = std::make_unique<NiceMock<MockVoldService>>();		auto vold = std::make_unique<NiceMock<MockVoldService>>();
	mVold = vold.get();		mVold = vold.get();
	auto incrementalManager = std::make_unique<NiceMock<MockIncrementalManager>>();		auto dataloaderManager = std::make_unique<NiceMock<MockDataLoaderManager>>();
	mIncrementalManager = incrementalManager.get();		mDataLoaderManager = dataloaderManager.get();
	auto incFs = std::make_unique<NiceMock<MockIncFs>>();		auto incFs = std::make_unique<NiceMock<MockIncFs>>();
	mIncFs = incFs.get();		mIncFs = incFs.get();
	mIncrementalService =		mIncrementalService =
	std::make_unique<IncrementalService>(MockServiceManager(std::move(vold),		std::make_unique<IncrementalService>(MockServiceManager(std::move(vold),
	std::move(		std::move(
	incrementalManager),		dataloaderManager),
	std::move(incFs)),		std::move(incFs)),
	mRootDir.path);		mRootDir.path);
	mDataLoaderParcel.packageName = "com.test";		mDataLoaderParcel.packageName = "com.test";
	@@ -260,7 +274,7 @@ public:
	protected:		protected:
	NiceMock<MockVoldService>* mVold;		NiceMock<MockVoldService>* mVold;
	NiceMock<MockIncFs>* mIncFs;		NiceMock<MockIncFs>* mIncFs;
	NiceMock<MockIncrementalManager>* mIncrementalManager;		NiceMock<MockDataLoaderManager>* mDataLoaderManager;
	std::unique_ptr<IncrementalService> mIncrementalService;		std::unique_ptr<IncrementalService> mIncrementalService;
	TemporaryDir mRootDir;		TemporaryDir mRootDir;
	DataLoaderParamsParcel mDataLoaderParcel;		DataLoaderParamsParcel mDataLoaderParcel;
	@@ -268,7 +282,7 @@ protected:

	TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {		TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {
	mVold->mountIncFsFails();		mVold->mountIncFsFails();
	EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);		EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},		mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
	@@ -278,7 +292,7 @@ TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {

	TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) {		TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) {
	mVold->mountIncFsInvalidControlParcel();		mVold->mountIncFsInvalidControlParcel();
	EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);		EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},		mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
	@@ -289,8 +303,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel)
	TEST_F(IncrementalServiceTest, testCreateStorageMakeFileFails) {		TEST_F(IncrementalServiceTest, testCreateStorageMakeFileFails) {
	mVold->mountIncFsSuccess();		mVold->mountIncFsSuccess();
	mIncFs->makeFileFails();		mIncFs->makeFileFails();
	EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);		EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
	EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));		EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
	EXPECT_CALL(*mVold, unmountIncFs(_));		EXPECT_CALL(*mVold, unmountIncFs(_));
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	@@ -303,8 +317,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageBindMountFails) {
	mVold->mountIncFsSuccess();		mVold->mountIncFsSuccess();
	mIncFs->makeFileSuccess();		mIncFs->makeFileSuccess();
	mVold->bindMountFails();		mVold->bindMountFails();
	EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);		EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
	EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));		EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
	EXPECT_CALL(*mVold, unmountIncFs(_));		EXPECT_CALL(*mVold, unmountIncFs(_));
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	@@ -317,8 +331,8 @@ TEST_F(IncrementalServiceTest, testCreateStoragePrepareDataLoaderFails) {
	mVold->mountIncFsSuccess();		mVold->mountIncFsSuccess();
	mIncFs->makeFileSuccess();		mIncFs->makeFileSuccess();
	mVold->bindMountSuccess();		mVold->bindMountSuccess();
	mIncrementalManager->prepareDataLoaderFails();		mDataLoaderManager->initializeDataLoaderFails();
	EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));		EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
	EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);		EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	@@ -331,8 +345,8 @@ TEST_F(IncrementalServiceTest, testDeleteStorageSuccess) {
	mVold->mountIncFsSuccess();		mVold->mountIncFsSuccess();
	mIncFs->makeFileSuccess();		mIncFs->makeFileSuccess();
	mVold->bindMountSuccess();		mVold->bindMountSuccess();
	mIncrementalManager->prepareDataLoaderSuccess();		mDataLoaderManager->initializeDataLoaderSuccess();
	EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));		EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
	EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);		EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	@@ -346,31 +360,31 @@ TEST_F(IncrementalServiceTest, testOnStatusNotReady) {
	mVold->mountIncFsSuccess();		mVold->mountIncFsSuccess();
	mIncFs->makeFileSuccess();		mIncFs->makeFileSuccess();
	mVold->bindMountSuccess();		mVold->bindMountSuccess();
	mIncrementalManager->prepareDataLoaderSuccess();		mDataLoaderManager->initializeDataLoaderSuccess();
	EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));		EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
	EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);		EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},		mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
	IncrementalService::CreateOptions::CreateNew);		IncrementalService::CreateOptions::CreateNew);
	ASSERT_GE(storageId, 0);		ASSERT_GE(storageId, 0);
	mIncrementalManager->setDataLoaderStatusNotReady();		mDataLoaderManager->setDataLoaderStatusNotReady();
	}		}

	TEST_F(IncrementalServiceTest, testStartDataLoaderSuccess) {		TEST_F(IncrementalServiceTest, testStartDataLoaderSuccess) {
	mVold->mountIncFsSuccess();		mVold->mountIncFsSuccess();
	mIncFs->makeFileSuccess();		mIncFs->makeFileSuccess();
	mVold->bindMountSuccess();		mVold->bindMountSuccess();
	mIncrementalManager->prepareDataLoaderSuccess();		mDataLoaderManager->initializeDataLoaderSuccess();
	mIncrementalManager->startDataLoaderSuccess();		mDataLoaderManager->getDataLoaderSuccess();
	EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));		EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
	EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);		EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},		mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
	IncrementalService::CreateOptions::CreateNew);		IncrementalService::CreateOptions::CreateNew);
	ASSERT_GE(storageId, 0);		ASSERT_GE(storageId, 0);
	mIncrementalManager->setDataLoaderStatusReady();		mDataLoaderManager->setDataLoaderStatusReady();
	ASSERT_TRUE(mIncrementalService->startLoading(storageId));		ASSERT_TRUE(mIncrementalService->startLoading(storageId));
	}		}

	@@ -378,8 +392,8 @@ TEST_F(IncrementalServiceTest, testMakeDirectory) {
	mVold->mountIncFsSuccess();		mVold->mountIncFsSuccess();
	mIncFs->makeFileSuccess();		mIncFs->makeFileSuccess();
	mVold->bindMountSuccess();		mVold->bindMountSuccess();
	mIncrementalManager->prepareDataLoaderSuccess();		mDataLoaderManager->initializeDataLoaderSuccess();
	mIncrementalManager->startDataLoaderSuccess();		mDataLoaderManager->getDataLoaderSuccess();
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},		mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
	@@ -402,8 +416,8 @@ TEST_F(IncrementalServiceTest, testMakeDirectories) {
	mVold->mountIncFsSuccess();		mVold->mountIncFsSuccess();
	mIncFs->makeFileSuccess();		mIncFs->makeFileSuccess();
	mVold->bindMountSuccess();		mVold->bindMountSuccess();
	mIncrementalManager->prepareDataLoaderSuccess();		mDataLoaderManager->initializeDataLoaderSuccess();
	mIncrementalManager->startDataLoaderSuccess();		mDataLoaderManager->getDataLoaderSuccess();
	TemporaryDir tempDir;		TemporaryDir tempDir;
	int storageId =		int storageId =
	mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},		mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},