0

Makes InstallablePageData a class

Makes all the properties type private and can only be set by the
On.*Fetched methods.

Bug: 1474631
Change-Id: Ia0ad051d284ed324d35d793792aa5656e83e717f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4908162
Commit-Queue: Ella Ge <eirage@chromium.org>
Reviewed-by: Daniel Murphy <dmurph@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1205880}
This commit is contained in:
Ella Ge
2023-10-05 16:32:59 +00:00
committed by Chromium LUCI CQ
parent ab64591573
commit c574f048c7
10 changed files with 199 additions and 136 deletions

@ -360,7 +360,7 @@ IN_PROC_BROWSER_TEST_F(InstallableManagerBrowserTest,
EXPECT_TRUE(blink::IsEmptyManifest(manager->manifest()));
EXPECT_TRUE(manager->manifest_url().is_empty());
EXPECT_FALSE(manager->page_data_->primary_icon->fetched);
EXPECT_FALSE(manager->page_data_->primary_icon_fetched());
EXPECT_FALSE(manager->has_worker());
EXPECT_EQ(NO_ERROR_DETECTED, manager->manifest_error());
@ -398,7 +398,7 @@ IN_PROC_BROWSER_TEST_F(InstallableManagerBrowserTest, ManagerInIncognito) {
EXPECT_TRUE(blink::IsEmptyManifest(manager->manifest()));
EXPECT_TRUE(manager->manifest_url().is_empty());
EXPECT_FALSE(manager->page_data_->primary_icon->fetched);
EXPECT_FALSE(manager->page_data_->primary_icon_fetched());
EXPECT_FALSE(manager->has_worker());
EXPECT_EQ(std::vector<InstallableStatusCode>{IN_INCOGNITO}, tester->errors());
@ -820,7 +820,7 @@ IN_PROC_BROWSER_TEST_F(InstallableManagerBrowserTest, CheckWebapp) {
EXPECT_FALSE(blink::IsEmptyManifest(manager->manifest()));
EXPECT_FALSE(manager->manifest_url().is_empty());
EXPECT_TRUE(manager->page_data_->primary_icon->fetched);
EXPECT_TRUE(manager->page_data_->primary_icon_fetched());
EXPECT_FALSE((manager->icon_url().is_empty()));
EXPECT_NE(nullptr, (manager->icon()));
EXPECT_EQ(NO_ERROR_DETECTED, manager->manifest_error());
@ -854,7 +854,7 @@ IN_PROC_BROWSER_TEST_F(InstallableManagerBrowserTest, CheckWebapp) {
EXPECT_FALSE(blink::IsEmptyManifest(manager->manifest()));
EXPECT_FALSE(manager->manifest_url().is_empty());
EXPECT_TRUE(manager->page_data_->primary_icon->fetched);
EXPECT_TRUE(manager->page_data_->primary_icon_fetched());
EXPECT_FALSE((manager->icon_url().is_empty()));
EXPECT_NE(nullptr, (manager->icon()));
EXPECT_EQ(NO_ERROR_DETECTED, manager->manifest_error());
@ -873,7 +873,7 @@ IN_PROC_BROWSER_TEST_F(InstallableManagerBrowserTest, CheckWebapp) {
EXPECT_TRUE(blink::IsEmptyManifest(manager->manifest()));
EXPECT_TRUE(manager->manifest_url().is_empty());
EXPECT_FALSE(manager->has_worker());
EXPECT_FALSE(manager->page_data_->primary_icon->fetched);
EXPECT_FALSE(manager->page_data_->primary_icon_fetched());
EXPECT_EQ(NO_ERROR_DETECTED, manager->manifest_error());
EXPECT_EQ(NO_ERROR_DETECTED, manager->worker_error());
EXPECT_TRUE(!manager->task_queue_.HasCurrent());
@ -1202,7 +1202,7 @@ IN_PROC_BROWSER_TEST_F(InstallableManagerBrowserTest,
EXPECT_FALSE(blink::IsEmptyManifest(manager->manifest()));
EXPECT_FALSE(manager->manifest_url().is_empty());
EXPECT_FALSE(manager->has_worker());
EXPECT_TRUE(manager->page_data_->primary_icon->fetched);
EXPECT_TRUE(manager->page_data_->primary_icon_fetched());
EXPECT_FALSE((manager->icon_url().is_empty()));
EXPECT_NE(nullptr, (manager->icon()));
EXPECT_EQ(NO_ERROR_DETECTED, manager->manifest_error());
@ -1250,7 +1250,7 @@ IN_PROC_BROWSER_TEST_F(InstallableManagerBrowserTest,
// Verify internal state.
EXPECT_FALSE(blink::IsEmptyManifest(manager->manifest()));
EXPECT_FALSE(manager->manifest_url().is_empty());
EXPECT_TRUE(manager->page_data_->primary_icon->fetched);
EXPECT_TRUE(manager->page_data_->primary_icon_fetched());
EXPECT_FALSE((manager->icon_url().is_empty()));
EXPECT_NE(nullptr, (manager->icon()));
EXPECT_EQ(NO_ERROR_DETECTED, manager->manifest_error());

@ -171,8 +171,7 @@ class TestInstallableManager : public InstallableManager {
}
void SetWebPageMetadata(mojom::WebPageMetadataPtr metadata) {
page_data_->web_page_metadata->metadata = std::move(metadata);
page_data_->web_page_metadata->fetched = true;
page_data_->OnPageMetadataFetched(std::move(metadata));
}
void SetManifest(blink::mojom::ManifestPtr manifest) {
@ -180,17 +179,14 @@ class TestInstallableManager : public InstallableManager {
SetPrimaryIcon(manifest->icons[0].src);
}
page_data_->manifest->manifest = std::move(manifest);
page_data_->manifest->url = GURL(kDefaultManifestUrl);
page_data_->manifest->fetched = true;
page_data_->OnManifestFetched(std::move(manifest),
GURL(kDefaultManifestUrl));
}
void SetPrimaryIcon(const GURL& icon_url) {
page_data_->primary_icon->url = icon_url;
page_data_->primary_icon->icon = std::make_unique<SkBitmap>(
page_data_->OnPrimaryIconFetched(
icon_url, blink::mojom::ManifestImageResource_Purpose::ANY,
gfx::test::CreateBitmap(kIconSizePx, kIconSizePx));
page_data_->primary_icon->error = NO_ERROR_DETECTED;
page_data_->primary_icon->fetched = true;
}
void SetShouldManifestTimeOut(bool should_time_out) {
@ -201,19 +197,19 @@ class TestInstallableManager : public InstallableManager {
void InitPageData() {
// Initialize all default values and set "fetched" to be true so the
// installable fetcher won't try to fetch the real data.
if (!page_data_->manifest->fetched) {
page_data_->manifest->fetched = true;
page_data_->manifest->error = MANIFEST_EMPTY;
if (!page_data_->manifest_fetched()) {
page_data_->OnManifestFetched(blink::mojom::Manifest::New(), GURL(),
MANIFEST_EMPTY);
}
if (!page_data_->web_page_metadata->fetched) {
page_data_->web_page_metadata->metadata = BuildDefaultMetadata();
page_data_->web_page_metadata->fetched = true;
if (!page_data_->web_page_metadata_fetched()) {
page_data_->OnPageMetadataFetched(BuildDefaultMetadata());
}
if (!page_data_->primary_icon->fetched) {
page_data_->primary_icon->fetched = true;
page_data_->primary_icon->error = NO_ACCEPTABLE_ICON;
if (!page_data_->primary_icon_fetched()) {
page_data_->OnPrimaryIconFetchedError(NO_ACCEPTABLE_ICON);
}
if (!page_data_->is_screenshots_fetch_complete()) {
page_data_->OnScreenshotsDownloaded(std::vector<Screenshot>());
}
page_data_->is_screenshots_fetch_complete = true;
}
bool should_manifest_time_out_ = false;

@ -39,9 +39,9 @@ InstallableDataFetcher::InstallableDataFetcher(
InstallableDataFetcher::~InstallableDataFetcher() = default;
void InstallableDataFetcher::FetchManifest(FetcherCallback finish_callback) {
if (page_data_->manifest->fetched) {
if (page_data_->manifest_fetched()) {
// Stop and run the callback if manifest is already fetched.
std::move(finish_callback).Run(page_data_->manifest->error);
std::move(finish_callback).Run(page_data_->manifest_error());
return;
}
@ -56,24 +56,22 @@ void InstallableDataFetcher::OnDidGetManifest(
FetcherCallback finish_callback,
const GURL& manifest_url,
blink::mojom::ManifestPtr manifest) {
InstallableStatusCode error = NO_ERROR_DETECTED;
if (manifest_url.is_empty()) {
page_data_->manifest->error = NO_MANIFEST;
error = NO_MANIFEST;
} else if (blink::IsEmptyManifest(manifest)) {
page_data_->manifest->error = MANIFEST_EMPTY;
error = MANIFEST_EMPTY;
}
page_data_->manifest->url = manifest_url;
page_data_->manifest->manifest = std::move(manifest);
page_data_->manifest->fetched = true;
std::move(finish_callback).Run(page_data_->manifest->error);
page_data_->OnManifestFetched(std::move(manifest), manifest_url, error);
std::move(finish_callback).Run(error);
}
void InstallableDataFetcher::FetchWebPageMetadata(
FetcherCallback finish_callback) {
if (page_data_->web_page_metadata->fetched) {
if (page_data_->web_page_metadata_fetched()) {
// Stop and run the callback if metadata is already fetched.
std::move(finish_callback).Run(page_data_->web_page_metadata->error);
std::move(finish_callback).Run(NO_ERROR_DETECTED);
return;
}
@ -96,8 +94,7 @@ void InstallableDataFetcher::OnDidGetWebPageMetadata(
mojo::AssociatedRemote<mojom::WebPageMetadataAgent> metadata_agent,
FetcherCallback finish_callback,
mojom::WebPageMetadataPtr web_page_metadata) {
page_data_->web_page_metadata->metadata = std::move(web_page_metadata);
page_data_->web_page_metadata->fetched = true;
page_data_->OnPageMetadataFetched(std::move(web_page_metadata));
std::move(finish_callback).Run(NO_ERROR_DETECTED);
}
@ -105,17 +102,13 @@ void InstallableDataFetcher::CheckServiceWorker(
FetcherCallback finish_callback,
base::OnceClosure pause_callback,
bool wait_for_worker) {
// Stop and run the callback if service worker is already checked.
// Sites can always register a service worker after we finish checking, so
// if the previous check result was a missing service worker error, we still
// check again.
if (page_data_->worker->fetched &&
page_data_->worker->error != NO_MATCHING_SERVICE_WORKER) {
std::move(finish_callback).Run(page_data_->worker->error);
// Stop and run the callback if we already have service worker result.
if (page_data_->HasWorkerResult()) {
std::move(finish_callback).Run(page_data_->worker_error());
return;
}
if (blink::IsEmptyManifest(*page_data_->manifest->manifest)) {
if (blink::IsEmptyManifest(page_data_->GetManifest())) {
// Skip fetching service worker and return if manifest is empty.
std::move(finish_callback).Run(NO_ERROR_DETECTED);
return;
@ -144,20 +137,17 @@ void InstallableDataFetcher::OnDidCheckHasServiceWorker(
content::ServiceWorkerCapability capability) {
switch (capability) {
case content::ServiceWorkerCapability::SERVICE_WORKER_WITH_FETCH_HANDLER:
page_data_->worker->has_worker = true;
page_data_->worker->error = NO_ERROR_DETECTED;
page_data_->OnCheckWorkerResult(NO_ERROR_DETECTED);
break;
case content::ServiceWorkerCapability::SERVICE_WORKER_NO_FETCH_HANDLER:
page_data_->worker->has_worker = false;
page_data_->worker->error = NOT_OFFLINE_CAPABLE;
page_data_->OnCheckWorkerResult(NOT_OFFLINE_CAPABLE);
break;
case content::ServiceWorkerCapability::NO_SERVICE_WORKER:
if (wait_for_worker) {
std::move(pause_callback).Run();
return;
} else {
page_data_->worker->has_worker = false;
page_data_->worker->error = NO_MATCHING_SERVICE_WORKER;
page_data_->OnCheckWorkerResult(NO_MATCHING_SERVICE_WORKER);
}
break;
}
@ -167,9 +157,8 @@ void InstallableDataFetcher::OnDidCheckHasServiceWorker(
InstallableMetrics::RecordCheckServiceWorkerStatus(
InstallableMetrics::ConvertFromServiceWorkerCapability(capability));
page_data_->worker->fetched = true;
if (finish_callback) {
std::move(finish_callback).Run(page_data_->worker->error);
std::move(finish_callback).Run(page_data_->worker_error());
}
}
@ -177,14 +166,13 @@ void InstallableDataFetcher::CheckAndFetchBestPrimaryIcon(
FetcherCallback finish_callback,
bool prefer_maskable,
bool fetch_favicon) {
if (blink::IsEmptyManifest(*page_data_->manifest->manifest) &&
!fetch_favicon) {
if (blink::IsEmptyManifest(page_data_->GetManifest()) && !fetch_favicon) {
std::move(finish_callback).Run(NO_ERROR_DETECTED);
return;
}
if (page_data_->primary_icon->fetched) {
if (page_data_->primary_icon_fetched()) {
// Stop and run the callback if an icon is already fetched.
std::move(finish_callback).Run(page_data_->primary_icon->error);
std::move(finish_callback).Run(page_data_->icon_error());
return;
}
icon_fetcher_ = std::make_unique<InstallableIconFetcher>(
@ -194,7 +182,7 @@ void InstallableDataFetcher::CheckAndFetchBestPrimaryIcon(
void InstallableDataFetcher::CheckAndFetchScreenshots(
FetcherCallback finish_callback) {
if (page_data_->is_screenshots_fetch_complete) {
if (page_data_->is_screenshots_fetch_complete()) {
// Stop and run the callback if screenshots was already fetched.
std::move(finish_callback).Run(NO_ERROR_DETECTED);
return;
@ -247,7 +235,7 @@ void InstallableDataFetcher::CheckAndFetchScreenshots(
}
if (!screenshots_downloading_) {
page_data_->is_screenshots_fetch_complete = true;
page_data_->OnScreenshotsDownloaded(std::vector<Screenshot>());
std::move(screenshot_complete_).Run(NO_ERROR_DETECTED);
}
}
@ -268,6 +256,7 @@ void InstallableDataFetcher::OnScreenshotFetched(GURL screenshot_url,
// Now that all images have finished downloading, populate screenshots in
// the order they are declared in the manifest.
int num_of_screenshots = 0;
std::vector<Screenshot> screenshots;
for (const auto& url : page_data_->GetManifest().screenshots) {
if (++num_of_screenshots > kMaximumNumOfScreenshots) {
break;
@ -286,11 +275,11 @@ void InstallableDataFetcher::OnScreenshotFetched(GURL screenshot_url,
// Screenshots must have the same aspect ratio. Cross-multiplying
// dimensions checks portrait vs landscape mode (1:2 vs 2:1 for instance).
if (page_data_->screenshots.size() &&
if (screenshots.size() &&
screenshot.dimensions().width() *
page_data_->screenshots[0].image.dimensions().height() !=
screenshots[0].image.dimensions().height() !=
screenshot.dimensions().height() *
page_data_->screenshots[0].image.dimensions().width()) {
screenshots[0].image.dimensions().width()) {
continue;
}
@ -300,11 +289,11 @@ void InstallableDataFetcher::OnScreenshotFetched(GURL screenshot_url,
continue;
}
page_data_->screenshots.emplace_back(std::move(screenshot), url->label);
screenshots.emplace_back(std::move(screenshot), url->label);
}
page_data_->OnScreenshotsDownloaded(std::move(screenshots));
downloaded_screenshots_.clear();
page_data_->is_screenshots_fetch_complete = true;
std::move(screenshot_complete_).Run(NO_ERROR_DETECTED);
}
}

@ -92,19 +92,19 @@ class InstallableEvaluatorUnitTest : public content::RenderViewHostTestHarness {
}
void SetManifest(blink::mojom::ManifestPtr manifest) {
page_data_->manifest->manifest = std::move(manifest);
page_data_->manifest_->manifest = std::move(manifest);
}
void SetMetadata(mojom::WebPageMetadataPtr metadata) {
page_data_->web_page_metadata->metadata = std::move(metadata);
page_data_->web_page_metadata_->metadata = (std::move(metadata));
}
blink::mojom::Manifest* manifest() {
return page_data_->manifest->manifest.get();
return page_data_->manifest_->manifest.get();
}
mojom::WebPageMetadata* metadata() {
return page_data_->web_page_metadata->metadata.get();
return page_data_->web_page_metadata_->metadata.get();
}
private:

@ -136,8 +136,6 @@ InstallableIconFetcher::InstallableIconFetcher(
prefer_maskable_(prefer_maskable),
fetch_favicon_(fetch_favicon),
finish_callback_(std::move(finish_callback)) {
page_data_->primary_icon->fetched = true;
downloading_icons_type_.push_back(IconPurpose::ANY);
if (prefer_maskable_) {
downloading_icons_type_.push_back(IconPurpose::MASKABLE);
@ -231,16 +229,12 @@ void InstallableIconFetcher::OnFaviconFetched(
void InstallableIconFetcher::OnIconFetched(const GURL& icon_url,
const IconPurpose purpose,
const SkBitmap& bitmap) {
page_data_->primary_icon->url = icon_url;
page_data_->primary_icon->icon = std::make_unique<SkBitmap>(bitmap);
page_data_->primary_icon->purpose = purpose;
page_data_->primary_icon->error = NO_ERROR_DETECTED;
page_data_->OnPrimaryIconFetched(icon_url, purpose, bitmap);
std::move(finish_callback_).Run(NO_ERROR_DETECTED);
}
void InstallableIconFetcher::EndWithError(InstallableStatusCode code) {
page_data_->primary_icon->error = code;
page_data_->OnPrimaryIconFetchedError(code);
std::move(finish_callback_).Run(code);
}

@ -124,23 +124,23 @@ void InstallableManager::SetSequencedTaskRunnerForTesting(
}
InstallableStatusCode InstallableManager::manifest_error() const {
return page_data_->manifest->error;
return page_data_->manifest_error();
}
InstallableStatusCode InstallableManager::worker_error() const {
return page_data_->worker->error;
return page_data_->worker_error();
}
InstallableStatusCode InstallableManager::icon_error() {
return page_data_->primary_icon->error;
InstallableStatusCode InstallableManager::icon_error() const {
return page_data_->icon_error();
}
GURL& InstallableManager::icon_url() {
return page_data_->primary_icon->url;
GURL InstallableManager::icon_url() const {
return page_data_->primary_icon_url();
}
const SkBitmap* InstallableManager::icon() {
return page_data_->primary_icon->icon.get();
const SkBitmap* InstallableManager::icon() const {
return page_data_->primary_icon();
}
content::WebContents* InstallableManager::GetWebContents() {
@ -233,15 +233,15 @@ void InstallableManager::WebContentsDestroyed() {
}
const GURL& InstallableManager::manifest_url() const {
return page_data_->manifest->url;
return page_data_->manifest_url();
}
const blink::mojom::Manifest& InstallableManager::manifest() const {
return page_data_->GetManifest();
}
bool InstallableManager::has_worker() {
return page_data_->worker->has_worker;
bool InstallableManager::has_worker() const {
return page_data_->has_worker();
}
WEB_CONTENTS_USER_DATA_KEY_IMPL(InstallableManager);

@ -105,9 +105,9 @@ class InstallableManager
// Gets/sets parts of particular properties. Exposed for testing.
InstallableStatusCode manifest_error() const;
InstallableStatusCode worker_error() const;
InstallableStatusCode icon_error();
GURL& icon_url();
const SkBitmap* icon();
InstallableStatusCode icon_error() const;
GURL icon_url() const;
const SkBitmap* icon() const;
// Returns the WebContents to which this object is attached, or nullptr if the
// WebContents doesn't exist or is currently being destroyed.
@ -134,7 +134,7 @@ class InstallableManager
const GURL& manifest_url() const;
const blink::mojom::Manifest& manifest() const;
bool has_worker();
bool has_worker() const;
std::unique_ptr<InstallablePageData> page_data_;
InstallableTaskQueue task_queue_;

@ -28,29 +28,80 @@ InstallablePageData::IconProperty& InstallablePageData::IconProperty::operator=(
InstallablePageData::IconProperty&& other) = default;
InstallablePageData::InstallablePageData()
: manifest(std::make_unique<ManifestProperty>()),
web_page_metadata(std::make_unique<WebPageMetadataProperty>()),
worker(std::make_unique<ServiceWorkerProperty>()),
primary_icon(std::make_unique<IconProperty>()) {}
: manifest_(std::make_unique<ManifestProperty>()),
web_page_metadata_(std::make_unique<WebPageMetadataProperty>()),
worker_(std::make_unique<ServiceWorkerProperty>()),
primary_icon_(std::make_unique<IconProperty>()) {}
InstallablePageData::~InstallablePageData() = default;
void InstallablePageData::Reset() {
manifest = std::make_unique<ManifestProperty>();
web_page_metadata = std::make_unique<WebPageMetadataProperty>();
worker = std::make_unique<ServiceWorkerProperty>();
primary_icon = std::make_unique<IconProperty>();
is_screenshots_fetch_complete = false;
manifest_ = std::make_unique<ManifestProperty>();
web_page_metadata_ = std::make_unique<WebPageMetadataProperty>();
worker_ = std::make_unique<ServiceWorkerProperty>();
primary_icon_ = std::make_unique<IconProperty>();
screenshots_.clear();
is_screenshots_fetch_complete_ = false;
}
void InstallablePageData::OnManifestFetched(blink::mojom::ManifestPtr manifest,
GURL manifest_url,
InstallableStatusCode error_code) {
CHECK(!manifest_->fetched);
manifest_->manifest = std::move(manifest);
manifest_->url = manifest_url;
manifest_->error = error_code;
manifest_->fetched = true;
}
void InstallablePageData::OnPageMetadataFetched(
mojom::WebPageMetadataPtr web_page_metadata) {
CHECK(!web_page_metadata_->fetched);
web_page_metadata_->metadata = std::move(web_page_metadata);
web_page_metadata_->fetched = true;
}
void InstallablePageData::OnCheckWorkerResult(InstallableStatusCode result) {
worker_->has_worker = (result == NO_ERROR_DETECTED);
worker_->error = result;
worker_->fetched = true;
}
void InstallablePageData::OnPrimaryIconFetched(const GURL& icon_url,
const IconPurpose purpose,
const SkBitmap& bitmap) {
primary_icon_->fetched = true;
primary_icon_->url = icon_url;
primary_icon_->icon = std::make_unique<SkBitmap>(bitmap);
primary_icon_->purpose = purpose;
primary_icon_->error = NO_ERROR_DETECTED;
}
void InstallablePageData::OnPrimaryIconFetchedError(
InstallableStatusCode code) {
primary_icon_->fetched = true;
primary_icon_->error = code;
}
void InstallablePageData::OnScreenshotsDownloaded(
std::vector<Screenshot> screenshots) {
CHECK(!is_screenshots_fetch_complete_);
screenshots_ = std::move(screenshots);
is_screenshots_fetch_complete_ = true;
}
const blink::mojom::Manifest& InstallablePageData::GetManifest() const {
DCHECK(manifest->manifest);
return *manifest->manifest;
DCHECK(manifest_->manifest);
return *manifest_->manifest;
}
const mojom::WebPageMetadata& InstallablePageData::WebPageMetadata() const {
DCHECK(web_page_metadata->metadata);
return *web_page_metadata->metadata;
DCHECK(web_page_metadata_->metadata);
return *web_page_metadata_->metadata;
}
bool InstallablePageData::HasWorkerResult() const {
return worker_->fetched && worker_->error != NO_MATCHING_SERVICE_WORKER;
}
} // namespace webapps

@ -15,8 +15,57 @@ namespace webapps {
using IconPurpose = blink::mojom::ManifestImageResource_Purpose;
// TODO(eriage): make this a class with proper getter and setter.
struct InstallablePageData {
class InstallablePageData {
public:
InstallablePageData();
~InstallablePageData();
InstallablePageData(const InstallablePageData&) = delete;
InstallablePageData& operator=(const InstallablePageData&) = delete;
InstallablePageData(InstallablePageData&& other) noexcept;
InstallablePageData& operator=(InstallablePageData&& other);
void Reset();
void OnManifestFetched(blink::mojom::ManifestPtr manifest,
GURL manifest_url,
InstallableStatusCode error = NO_ERROR_DETECTED);
void OnPageMetadataFetched(mojom::WebPageMetadataPtr web_page_metadata);
void OnCheckWorkerResult(InstallableStatusCode result);
void OnPrimaryIconFetched(const GURL& icon_url,
const IconPurpose purpose,
const SkBitmap& bitmap);
void OnPrimaryIconFetchedError(InstallableStatusCode code);
void OnScreenshotsDownloaded(std::vector<Screenshot> screenshots);
const blink::mojom::Manifest& GetManifest() const;
const mojom::WebPageMetadata& WebPageMetadata() const;
// Return if service worker is already checked and we have a final result.
// Sites can always register a service worker after last check, so
// if the previous check result was a missing service worker error, we still
// want to check again.
bool HasWorkerResult() const;
const GURL& manifest_url() const { return manifest_->url; }
InstallableStatusCode manifest_error() const { return manifest_->error; }
bool manifest_fetched() const { return manifest_->fetched; }
bool web_page_metadata_fetched() const { return web_page_metadata_->fetched; }
bool has_worker() const { return worker_->has_worker; }
InstallableStatusCode worker_error() const { return worker_->error; }
const SkBitmap* primary_icon() const { return primary_icon_->icon.get(); }
IconPurpose primary_icon_purpose() const { return primary_icon_->purpose; }
const GURL& primary_icon_url() const { return primary_icon_->url; }
InstallableStatusCode icon_error() const { return primary_icon_->error; }
bool primary_icon_fetched() const { return primary_icon_->fetched; }
const std::vector<Screenshot>& screenshots() const { return screenshots_; }
bool is_screenshots_fetch_complete() const {
return is_screenshots_fetch_complete_;
}
private:
friend class InstallableEvaluatorUnitTest;
struct ManifestProperty {
ManifestProperty();
~ManifestProperty();
@ -31,7 +80,6 @@ struct InstallablePageData {
WebPageMetadataProperty();
~WebPageMetadataProperty();
InstallableStatusCode error = NO_ERROR_DETECTED;
mojom::WebPageMetadataPtr metadata = mojom::WebPageMetadata::New();
bool fetched = false;
};
@ -39,7 +87,6 @@ struct InstallablePageData {
struct ServiceWorkerProperty {
InstallableStatusCode error = NO_ERROR_DETECTED;
bool has_worker = false;
bool is_waiting = false;
bool fetched = false;
};
@ -55,32 +102,18 @@ struct InstallablePageData {
~IconProperty();
InstallableStatusCode error = NO_ERROR_DETECTED;
IconPurpose purpose = blink::mojom::ManifestImageResource_Purpose::ANY;
IconPurpose purpose = IconPurpose::ANY;
GURL url;
std::unique_ptr<SkBitmap> icon;
bool fetched = false;
};
InstallablePageData();
~InstallablePageData();
InstallablePageData(const InstallablePageData&) = delete;
InstallablePageData& operator=(const InstallablePageData&) = delete;
InstallablePageData(InstallablePageData&& other) noexcept;
InstallablePageData& operator=(InstallablePageData&& other);
void Reset();
const blink::mojom::Manifest& GetManifest() const;
const mojom::WebPageMetadata& WebPageMetadata() const;
std::unique_ptr<ManifestProperty> manifest;
std::unique_ptr<WebPageMetadataProperty> web_page_metadata;
std::unique_ptr<ServiceWorkerProperty> worker;
std::unique_ptr<IconProperty> primary_icon;
std::vector<Screenshot> screenshots;
bool is_screenshots_fetch_complete = false;
std::unique_ptr<ManifestProperty> manifest_;
std::unique_ptr<WebPageMetadataProperty> web_page_metadata_;
std::unique_ptr<ServiceWorkerProperty> worker_;
std::unique_ptr<IconProperty> primary_icon_;
std::vector<Screenshot> screenshots_;
bool is_screenshots_fetch_complete_ = false;
};
} // namespace webapps

@ -42,14 +42,14 @@ void InstallableTask::RunCallback() {
if (callback_) {
InstallableData data = {
std::move(errors_),
page_data_->manifest->url,
page_data_->manifest_url(),
page_data_->GetManifest(),
page_data_->WebPageMetadata(),
page_data_->primary_icon->url,
page_data_->primary_icon->icon.get(),
page_data_->primary_icon->purpose ==
page_data_->primary_icon_url(),
page_data_->primary_icon(),
page_data_->primary_icon_purpose() ==
blink::mojom::ManifestImageResource_Purpose::MASKABLE,
page_data_->screenshots,
page_data_->screenshots(),
valid_manifest_,
};
std::move(callback_).Run(data);