Offline pages : Fixed received_bytes for OfflineItem conversion

Fixed the received_bytes field for offline pages to OfflineItem conversion.
Also added all the missing fields to the conversion unit tests.

Bug: 897841
Change-Id: I823a84bc36a9d07c2f955f756c91412d22fa59ae
Reviewed-on: https://chromium-review.googlesource.com/c/1294404
Commit-Queue: Shakti Sahu <shaktisahu@chromium.org>
Reviewed-by: Carlos Knippschild <carlosk@chromium.org>
Reviewed-by: Shakti Sahu <shaktisahu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#602110}

components/offline_pages/core/downloads/download_ui_adapter_unittest.cc

@@ -351,19 +351,23 @@ TEST_F(DownloadUIAdapterTest, InitialItemConversion) {
   EXPECT_EQ(1UL, model->pages.size());
   EXPECT_EQ(kTestGuid1, model->pages[kTestOfflineId1].client_id.id);
 
-  auto callback = [](const base::Optional<OfflineItem>& item) {
-    EXPECT_EQ(kTestGuid1, item.value().id.id);
-    EXPECT_EQ(kTestUrl, item.value().page_url.spec());
-    EXPECT_EQ(OfflineItemState::COMPLETE, item.value().state);
-    EXPECT_EQ(0, item.value().received_bytes);
-    EXPECT_EQ(kTestFilePath, item.value().file_path);
-    EXPECT_EQ(kTestCreationTime, item.value().creation_time);
-    EXPECT_EQ(kFileSize, item.value().total_size_bytes);
-    EXPECT_EQ(kTestTitle, base::ASCIIToUTF16(item.value().title));
-  };
-
-  adapter->GetItemById(kTestContentId1, base::BindOnce(callback));
+  bool called = false;
+  auto callback =
+      base::BindLambdaForTesting([&](const base::Optional<OfflineItem>& item) {
+        EXPECT_EQ(kTestGuid1, item.value().id.id);
+        EXPECT_EQ(kTestUrl, item.value().page_url.spec());
+        EXPECT_EQ(OfflineItemState::COMPLETE, item.value().state);
+        EXPECT_EQ(kFileSize, item.value().received_bytes);
+        EXPECT_EQ(kTestFilePath, item.value().file_path);
+        EXPECT_EQ(kTestCreationTime, item.value().creation_time);
+        EXPECT_EQ(kFileSize, item.value().total_size_bytes);
+        EXPECT_EQ(kTestTitle, base::ASCIIToUTF16(item.value().title));
+        called = true;
+      });
+
+  adapter->GetItemById(kTestContentId1, callback);
   PumpLoop();
+  EXPECT_TRUE(called);
 }
 
 TEST_F(DownloadUIAdapterTest, ItemDeletedAdded) {

components/offline_pages/core/downloads/offline_item_conversions.cc

@@ -50,6 +50,7 @@ OfflineItem OfflineItemConversions::CreateOfflineItem(
   item.filter = OfflineItemFilter::FILTER_PAGE;
   item.state = OfflineItemState::COMPLETE;
   item.total_size_bytes = page.file_size;
+  item.received_bytes = page.file_size;
   item.creation_time = page.creation_time;
   // Completion time is the time when the offline archive was created.
   item.completion_time = page.creation_time;

components/offline_pages/core/downloads/offline_item_conversions_unittest.cc

@@ -20,8 +20,13 @@ using OfflineItemProgressUnit =
 
 namespace offline_pages {
 
+namespace {
+const GURL kTestUrl("http://www.example.com");
+const GURL kTestOriginalUrl("http://www.exampleoriginalurl.com");
+
+}  // namespace
+
 TEST(OfflineItemConversionsTest, OfflinePageItemConversion) {
-  GURL url("example_url");
   std::string name_space = "test_namespace";
   std::string guid = "test_guid";
   ClientId client_id(name_space, guid);
@@ -32,21 +37,26 @@ TEST(OfflineItemConversionsTest, OfflinePageItemConversion) {
   base::Time last_access_time = base::Time::Now();
   std::string title = "test title";
 
-  OfflinePageItem offline_page_item(url, offline_id, client_id, file_path,
+  OfflinePageItem offline_page_item(kTestUrl, offline_id, client_id, file_path,
                                     file_size, creation_time);
+  offline_page_item.original_url = kTestOriginalUrl;
   offline_page_item.title = base::UTF8ToUTF16(title);
   offline_page_item.last_access_time = last_access_time;
+  offline_page_item.file_missing_time = base::Time::Now();
 
   OfflineItem offline_item =
       OfflineItemConversions::CreateOfflineItem(offline_page_item, true);
 
   EXPECT_EQ(ContentId(kOfflinePageNamespace, guid), offline_item.id);
-  EXPECT_EQ(url, offline_item.page_url);
+  EXPECT_EQ(kTestUrl, offline_item.page_url);
+  EXPECT_EQ(kTestOriginalUrl, offline_item.original_url);
   EXPECT_EQ(title, offline_item.title);
   EXPECT_EQ(file_path, offline_item.file_path);
   EXPECT_EQ(creation_time, offline_item.creation_time);
+  EXPECT_EQ(creation_time, offline_item.completion_time);
   EXPECT_EQ(last_access_time, offline_item.last_accessed_time);
   EXPECT_EQ(file_size, offline_item.total_size_bytes);
+  EXPECT_EQ(file_size, offline_item.received_bytes);
   EXPECT_EQ("multipart/related", offline_item.mime_type);
   EXPECT_EQ(OfflineItemFilter::FILTER_PAGE, offline_item.filter);
   EXPECT_EQ(OfflineItemState::COMPLETE, offline_item.state);
@@ -56,7 +66,9 @@ TEST(OfflineItemConversionsTest, OfflinePageItemConversion) {
   EXPECT_EQ(OfflineItemProgressUnit::PERCENTAGE, offline_item.progress.unit);
   EXPECT_TRUE(offline_item.is_suggested);
   EXPECT_TRUE(offline_item.is_openable);
-  EXPECT_FALSE(offline_item.externally_removed);
+  EXPECT_TRUE(offline_item.externally_removed);
+  EXPECT_EQ(FailState::NO_FAILURE, offline_item.fail_state);
+  EXPECT_EQ(PendingState::NOT_PENDING, offline_item.pending_state);
 
   // Enabled P2P sharing and flag the item as suggested when creating the
   // OfflineItem. Then check that only the mime type is and is_suggested
@@ -75,26 +87,32 @@ TEST(OfflineItemConversionsTest, OfflinePageItemConversion) {
 }
 
 TEST(OfflineItemConversionsTest, SavePageRequestConversion) {
-  GURL url("example_url");
   std::string name_space = "test_namespace";
   std::string guid = "test_guid";
   ClientId client_id(name_space, guid);
   int64_t request_id = 5;
   base::Time creation_time = base::Time::Now();
 
-  SavePageRequest save_page_request(request_id, url, client_id, creation_time,
-                                    false);
+  SavePageRequest save_page_request(request_id, kTestUrl, client_id,
+                                    creation_time, false);
+  save_page_request.set_original_url(kTestOriginalUrl);
   save_page_request.set_request_state(SavePageRequest::RequestState::OFFLINING);
+  save_page_request.set_fail_state(FailState::NETWORK_FAILED);
+  save_page_request.set_pending_state(PendingState::PENDING_ANOTHER_DOWNLOAD);
 
   OfflineItem offline_item =
       OfflineItemConversions::CreateOfflineItem(save_page_request);
 
   EXPECT_EQ(ContentId(kOfflinePageNamespace, guid), offline_item.id);
-  EXPECT_EQ(url, offline_item.page_url);
-  EXPECT_EQ("", offline_item.title);
+  EXPECT_EQ(kTestUrl, offline_item.page_url);
+  EXPECT_EQ(kTestOriginalUrl, offline_item.original_url);
+  EXPECT_EQ(kTestUrl.host(), offline_item.title);
   EXPECT_EQ(base::FilePath(), offline_item.file_path);
   EXPECT_EQ(creation_time, offline_item.creation_time);
+  EXPECT_EQ(base::Time(), offline_item.completion_time);
   EXPECT_EQ(base::Time(), offline_item.last_accessed_time);
+  EXPECT_EQ(-1L, offline_item.total_size_bytes);
+  EXPECT_EQ(0, offline_item.received_bytes);
   EXPECT_EQ("multipart/related", offline_item.mime_type);
   EXPECT_EQ(OfflineItemFilter::FILTER_PAGE, offline_item.filter);
   EXPECT_EQ(OfflineItemState::IN_PROGRESS, offline_item.state);
@@ -102,6 +120,8 @@ TEST(OfflineItemConversionsTest, SavePageRequestConversion) {
   EXPECT_FALSE(offline_item.progress.max.has_value());
   EXPECT_EQ(OfflineItemProgressUnit::PERCENTAGE, offline_item.progress.unit);
   EXPECT_FALSE(offline_item.is_suggested);
+  EXPECT_EQ(FailState::NETWORK_FAILED, offline_item.fail_state);
+  EXPECT_EQ(PendingState::NOT_PENDING, offline_item.pending_state);
 
   // Disable P2P sharing of offline pages and check that only the mime type is
   // different.