[Offline pages] Adding bookmark ID to offline page (removing title)

This change is necessary, as title is already stored by the bookmark, while bookmark ID is how all the filtering and matching is done by the model and UI.
Without this update any filtering logic will be very inefficient.

BUG=491352

Review URL: https://codereview.chromium.org/1262743006

Cr-Commit-Position: refs/heads/master@{#342206}

9 files changed, 136 insertions, 132 deletions

diff --git a/components/offline_pages/offline_page_archiver.h b/components/offline_pages/offline_page_archiver.h
index a9f06ba..9cec07f 100644
--- a/components/offline_pages/offline_page_archiver.h
+++ b/components/offline_pages/offline_page_archiver.h
@@ -57,7 +57,6 @@ class OfflinePageArchiver {
   typedef base::Callback<void(OfflinePageArchiver* /* archiver */,
                               ArchiverResult /* result */,
                               const GURL& /* url */,
-                              const base::string16& /* title */,
                               const base::FilePath& /* file_path */,
                               int64 /* file_size */)> CreateArchiveCallback;
 
diff --git a/components/offline_pages/offline_page_item.cc b/components/offline_pages/offline_page_item.cc
index 0631cbb..4e4d697 100644
--- a/components/offline_pages/offline_page_item.cc
+++ b/components/offline_pages/offline_page_item.cc
@@ -18,23 +18,23 @@ OfflinePageItem::OfflinePageItem()
 }
 
 OfflinePageItem::OfflinePageItem(const GURL& url,
-                                 const base::string16& title,
+                                 int64 bookmark_id,
                                  const base::FilePath& file_path,
                                  int64 file_size)
     : url(url),
-      title(title),
+      bookmark_id(bookmark_id),
       version(kCurrentVersion),
       file_path(file_path),
       file_size(file_size) {
 }
 
 OfflinePageItem::OfflinePageItem(const GURL& url,
-                                 const base::string16& title,
+                                 int64 bookmark_id,
                                  const base::FilePath& file_path,
                                  int64 file_size,
                                  const base::Time& creation_time)
     : url(url),
-      title(title),
+      bookmark_id(bookmark_id),
       version(kCurrentVersion),
       file_path(file_path),
       file_size(file_size),
diff --git a/components/offline_pages/offline_page_item.h b/components/offline_pages/offline_page_item.h
index 99ed8a4..ac9bcb8 100644
--- a/components/offline_pages/offline_page_item.h
+++ b/components/offline_pages/offline_page_item.h
@@ -20,11 +20,11 @@ struct OfflinePageItem {
  public:
   OfflinePageItem();
   OfflinePageItem(const GURL& url,
-                  const base::string16& title,
+                  int64 bookmark_id,
                   const base::FilePath& file_path,
                   int64 file_size);
   OfflinePageItem(const GURL& url,
-                  const base::string16& title,
+                  int64 bookmark_id,
                   const base::FilePath& file_path,
                   int64 file_size,
                   const base::Time& creation_time);
@@ -35,8 +35,8 @@ struct OfflinePageItem {
 
   // The URL of the page.
   GURL url;
-  // The title of the page.
-  base::string16 title;
+  // The Bookmark ID related to the offline page.
+  int64 bookmark_id;
   // Version of the offline page item.
   int version;
   // The file path to the archive with a local copy of the page.
diff --git a/components/offline_pages/offline_page_metadata_store_impl.cc b/components/offline_pages/offline_page_metadata_store_impl.cc
index e19585fa..c68c676 100644
--- a/components/offline_pages/offline_page_metadata_store_impl.cc
+++ b/components/offline_pages/offline_page_metadata_store_impl.cc
@@ -29,7 +29,7 @@ void OfflinePageItemToEntry(const OfflinePageItem& item,
                             offline_pages::OfflinePageEntry* item_proto) {
   DCHECK(item_proto);
   item_proto->set_url(item.url.spec());
-  item_proto->set_title(base::UTF16ToUTF8(item.title));
+  item_proto->set_bookmark_id(item.bookmark_id);
   item_proto->set_version(item.version);
   std::string path_string;
 #if defined(OS_POSIX)
@@ -46,12 +46,12 @@ void OfflinePageItemToEntry(const OfflinePageItem& item,
 bool OfflinePageItemFromEntry(const offline_pages::OfflinePageEntry& item_proto,
                               OfflinePageItem* item) {
   DCHECK(item);
-  if (!item_proto.has_url() || !item_proto.has_title() ||
+  if (!item_proto.has_url() || !item_proto.has_bookmark_id() ||
       !item_proto.has_version() || !item_proto.has_file_path()) {
     return false;
   }
   item->url = GURL(item_proto.url());
-  item->title = base::UTF8ToUTF16(item_proto.title());
+  item->bookmark_id = item_proto.bookmark_id();
   item->version = item_proto.version();
 #if defined(OS_POSIX)
   item->file_path = base::FilePath(item_proto.file_path());
diff --git a/components/offline_pages/offline_page_metadata_store_impl_unittest.cc b/components/offline_pages/offline_page_metadata_store_impl_unittest.cc
index 7e7685e..051aaae 100644
--- a/components/offline_pages/offline_page_metadata_store_impl_unittest.cc
+++ b/components/offline_pages/offline_page_metadata_store_impl_unittest.cc
@@ -23,7 +23,7 @@ namespace offline_pages {
 namespace {
 
 const char kTestURL[] = "https://example.com";
-const base::string16 kTestTitle = base::ASCIIToUTF16("Example site title");
+const int64 kTestBookmarkId = 1234LL;
 const base::FilePath::CharType kFilePath[] =
     FILE_PATH_LITERAL("/offline_pages/example_com.mhtml");
 int64 kFileSize = 234567;
@@ -120,7 +120,7 @@ TEST_F(OfflinePageMetadataStoreImplTest, LoadEmptyStore) {
 TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageThenLoad) {
   scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
 
-  OfflinePageItem offline_page(GURL(kTestURL), kTestTitle,
+  OfflinePageItem offline_page(GURL(kTestURL), kTestBookmarkId,
                                base::FilePath(kFilePath), kFileSize);
   store->AddOfflinePage(
       offline_page,
@@ -139,7 +139,7 @@ TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageThenLoad) {
   EXPECT_EQ(STATUS_TRUE, last_status_);
   EXPECT_EQ(1U, offline_pages_.size());
   EXPECT_EQ(offline_page.url, offline_pages_[0].url);
-  EXPECT_EQ(offline_page.title, offline_pages_[0].title);
+  EXPECT_EQ(offline_page.bookmark_id, offline_pages_[0].bookmark_id);
   EXPECT_EQ(offline_page.version, offline_pages_[0].version);
   EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path);
   EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size);
@@ -152,7 +152,7 @@ TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageThenLoad) {
 TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageRestartLoad) {
   scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
 
-  OfflinePageItem offline_page(GURL(kTestURL), kTestTitle,
+  OfflinePageItem offline_page(GURL(kTestURL), kTestBookmarkId,
                                base::FilePath(kFilePath), kFileSize);
   store->AddOfflinePage(
       offline_page,
@@ -174,7 +174,7 @@ TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageRestartLoad) {
   EXPECT_EQ(STATUS_TRUE, last_status_);
   EXPECT_EQ(1U, offline_pages_.size());
   EXPECT_EQ(offline_page.url, offline_pages_[0].url);
-  EXPECT_EQ(offline_page.title, offline_pages_[0].title);
+  EXPECT_EQ(offline_page.bookmark_id, offline_pages_[0].bookmark_id);
   EXPECT_EQ(offline_page.version, offline_pages_[0].version);
   EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path);
   EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size);
@@ -187,7 +187,7 @@ TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageRestartLoad) {
 TEST_F(OfflinePageMetadataStoreImplTest, RemoveOfflinePage) {
   scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
 
-  OfflinePageItem offline_page(GURL(kTestURL), kTestTitle,
+  OfflinePageItem offline_page(GURL(kTestURL), kTestBookmarkId,
                                base::FilePath(kFilePath), kFileSize);
   store->AddOfflinePage(
       offline_page,
@@ -244,12 +244,11 @@ TEST_F(OfflinePageMetadataStoreImplTest, RemoveOfflinePage) {
 TEST_F(OfflinePageMetadataStoreImplTest, AddRemoveMultipleOfflinePages) {
   scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore());
 
-  OfflinePageItem offline_page_1(GURL(kTestURL), kTestTitle,
+  OfflinePageItem offline_page_1(GURL(kTestURL), kTestBookmarkId,
                                  base::FilePath(kFilePath), kFileSize);
   base::FilePath file_path_2 =
       base::FilePath(FILE_PATH_LITERAL("//other.page.com.mhtml"));
-  OfflinePageItem offline_page_2(GURL("https://other.page.com"),
-                                 base::ASCIIToUTF16("Other page"),
+  OfflinePageItem offline_page_2(GURL("https://other.page.com"), 5678LL,
                                  file_path_2, 12345, base::Time::Now());
   store->AddOfflinePage(
       offline_page_1,
@@ -296,7 +295,7 @@ TEST_F(OfflinePageMetadataStoreImplTest, AddRemoveMultipleOfflinePages) {
   EXPECT_EQ(STATUS_TRUE, last_status_);
   EXPECT_EQ(1U, offline_pages_.size());
   EXPECT_EQ(offline_page_2.url, offline_pages_[0].url);
-  EXPECT_EQ(offline_page_2.title, offline_pages_[0].title);
+  EXPECT_EQ(offline_page_2.bookmark_id, offline_pages_[0].bookmark_id);
   EXPECT_EQ(offline_page_2.version, offline_pages_[0].version);
   EXPECT_EQ(offline_page_2.file_path, offline_pages_[0].file_path);
   EXPECT_EQ(offline_page_2.file_size, offline_pages_[0].file_size);
diff --git a/components/offline_pages/offline_page_model.cc b/components/offline_pages/offline_page_model.cc
index 09633fb..c8f9d4fd 100644
--- a/components/offline_pages/offline_page_model.cc
+++ b/components/offline_pages/offline_page_model.cc
@@ -63,14 +63,14 @@ OfflinePageModel::~OfflinePageModel() {
 void OfflinePageModel::Shutdown() {
 }
 
-void OfflinePageModel::SavePage(
-    const GURL& url,
-    scoped_ptr<OfflinePageArchiver> archiver,
-    const SavePageCallback& callback) {
+void OfflinePageModel::SavePage(const GURL& url,
+                                int64 bookmark_id,
+                                scoped_ptr<OfflinePageArchiver> archiver,
+                                const SavePageCallback& callback) {
   DCHECK(archiver.get());
   archiver->CreateArchive(base::Bind(&OfflinePageModel::OnCreateArchiveDone,
                                      weak_ptr_factory_.GetWeakPtr(), url,
-                                     callback));
+                                     bookmark_id, callback));
   pending_archivers_.push_back(archiver.Pass());
 }
 
@@ -91,15 +91,14 @@ OfflinePageMetadataStore* OfflinePageModel::GetStoreForTesting() {
   return store_.get();
 }
 
-void OfflinePageModel::OnCreateArchiveDone(
-    const GURL& requested_url,
-    const SavePageCallback& callback,
-    OfflinePageArchiver* archiver,
-    ArchiverResult archiver_result,
-    const GURL& url,
-    const base::string16& title,
-    const base::FilePath& file_path,
-    int64 file_size) {
+void OfflinePageModel::OnCreateArchiveDone(const GURL& requested_url,
+                                           int64 bookmark_id,
+                                           const SavePageCallback& callback,
+                                           OfflinePageArchiver* archiver,
+                                           ArchiverResult archiver_result,
+                                           const GURL& url,
+                                           const base::FilePath& file_path,
+                                           int64 file_size) {
   if (requested_url != url) {
     DVLOG(1) << "Saved URL does not match requested URL.";
     // TODO(fgorski): We have created an archive for a wrong URL. It should be
@@ -116,7 +115,7 @@ void OfflinePageModel::OnCreateArchiveDone(
     return;
   }
 
-  OfflinePageItem offline_page_item(url, title, file_path, file_size,
+  OfflinePageItem offline_page_item(url, bookmark_id, file_path, file_size,
                                     base::Time::Now());
   store_->AddOfflinePage(
       offline_page_item,
diff --git a/components/offline_pages/offline_page_model.h b/components/offline_pages/offline_page_model.h
index c42feb4..ad54731 100644
--- a/components/offline_pages/offline_page_model.h
+++ b/components/offline_pages/offline_page_model.h
@@ -98,6 +98,7 @@ class OfflinePageModel : public KeyedService {
 
   // Attempts to save a page addressed by |url| offline.
   void SavePage(const GURL& url,
+                int64 bookmark_id,
                 scoped_ptr<OfflinePageArchiver> archiver,
                 const SavePageCallback& callback);
 
@@ -115,11 +116,11 @@ class OfflinePageModel : public KeyedService {
 
   // OfflinePageArchiver callback.
   void OnCreateArchiveDone(const GURL& requested_url,
+                           int64 bookmark_id,
                            const SavePageCallback& callback,
                            OfflinePageArchiver* archiver,
                            OfflinePageArchiver::ArchiverResult result,
                            const GURL& url,
-                           const base::string16& title,
                            const base::FilePath& file_path,
                            int64 file_size);
 
diff --git a/components/offline_pages/offline_page_model_unittest.cc b/components/offline_pages/offline_page_model_unittest.cc
index 4c66c8e..2d1038a 100644
--- a/components/offline_pages/offline_page_model_unittest.cc
+++ b/components/offline_pages/offline_page_model_unittest.cc
@@ -27,9 +27,9 @@ namespace offline_pages {
 
 namespace {
 const GURL kTestUrl("http://example.com");
-const base::string16 kTestPageTitle = base::ASCIIToUTF16("Test Page Title");
+const int64 kTestPageBookmarkId1 = 1234LL;
 const GURL kTestUrl2("http://other.page.com");
-const base::string16 kTestPageTitle2 = base::ASCIIToUTF16("Other page title");
+const int64 kTestPageBookmarkId2 = 5678LL;
 const int64 kTestFileSize = 876543LL;
 
 class OfflinePageTestStore : public OfflinePageMetadataStore {
@@ -124,7 +124,6 @@ class OfflinePageTestArchiver : public OfflinePageArchiver {
   OfflinePageTestArchiver(
       OfflinePageModelTest* test,
       const GURL& url,
-      const base::string16& title,
       const base::FilePath& archiver_dir,
       ArchiverResult result,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
@@ -142,7 +141,6 @@ class OfflinePageTestArchiver : public OfflinePageArchiver {
  private:
   OfflinePageModelTest* test_;  // Outlive OfflinePageTestArchiver.
   GURL url_;
-  base::string16 title_;
   base::FilePath archiver_dir_;
   ArchiverResult result_;
   bool create_archive_called_;
@@ -169,7 +167,6 @@ class OfflinePageModelTest
 
   scoped_ptr<OfflinePageTestArchiver> BuildArchiver(
       const GURL& url,
-      const base::string16& title,
       OfflinePageArchiver::ArchiverResult result);
   scoped_ptr<OfflinePageMetadataStore> BuildStore();
   scoped_ptr<OfflinePageModel> BuildModel();
@@ -223,13 +220,11 @@ class OfflinePageModelTest
 OfflinePageTestArchiver::OfflinePageTestArchiver(
     OfflinePageModelTest* test,
     const GURL& url,
-    const base::string16& title,
     const base::FilePath& archiver_dir,
     ArchiverResult result,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : test_(test),
       url_(url),
-      title_(title),
       archiver_dir_(archiver_dir),
       result_(result),
       create_archive_called_(false),
@@ -254,10 +249,8 @@ void OfflinePageTestArchiver::CompleteCreateArchive() {
   base::FilePath archiver_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(archiver_dir_, &archiver_path));
   test_->set_last_archiver_path(archiver_path);
-  task_runner_->PostTask(
-      FROM_HERE, base::Bind(callback_, this, result_, url_, title_,
-                            archiver_path,
-                            kTestFileSize));
+  task_runner_->PostTask(FROM_HERE, base::Bind(callback_, this, result_, url_,
+                                               archiver_path, kTestFileSize));
 }
 
 OfflinePageModelTest::OfflinePageModelTest()
@@ -294,10 +287,10 @@ void OfflinePageModelTest::OnDeletePageDone(DeletePageResult result) {
 }
 
 scoped_ptr<OfflinePageTestArchiver> OfflinePageModelTest::BuildArchiver(
-    const GURL& url, const base::string16& title,
+    const GURL& url,
     OfflinePageArchiver::ArchiverResult result) {
   return scoped_ptr<OfflinePageTestArchiver>(new OfflinePageTestArchiver(
-      this, url, title, temp_dir_.path(), result, task_runner()));
+      this, url, temp_dir_.path(), result, task_runner()));
 }
 
 scoped_ptr<OfflinePageMetadataStore> OfflinePageModelTest::BuildStore() {
@@ -328,17 +321,18 @@ OfflinePageTestStore* OfflinePageModelTest::GetStore() {
 }
 
 TEST_F(OfflinePageModelTest, SavePageSuccessful) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED).Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   OfflinePageTestStore* store = GetStore();
   EXPECT_EQ(kTestUrl, store->last_saved_page().url);
-  EXPECT_EQ(kTestPageTitle, store->last_saved_page().title);
+  EXPECT_EQ(kTestPageBookmarkId1, store->last_saved_page().bookmark_id);
   // Save last_archiver_path since it will be referred to later.
   base::FilePath archiver_path = last_archiver_path();
   EXPECT_EQ(archiver_path, store->last_saved_page().file_path);
@@ -353,63 +347,69 @@ TEST_F(OfflinePageModelTest, SavePageSuccessful) {
   EXPECT_EQ(LoadResult::SUCCESS, last_load_result());
   EXPECT_EQ(1UL, last_loaded_pages().size());
   EXPECT_EQ(kTestUrl, last_loaded_pages()[0].url);
-  EXPECT_EQ(kTestPageTitle, last_loaded_pages()[0].title);
+  EXPECT_EQ(kTestPageBookmarkId1, last_loaded_pages()[0].bookmark_id);
   EXPECT_EQ(archiver_path, last_loaded_pages()[0].file_path);
   EXPECT_EQ(kTestFileSize, last_loaded_pages()[0].file_size);
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineArchiverCancelled) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::ERROR_CANCELED).Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::ERROR_CANCELED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(SavePageResult::CANCELLED, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineArchiverDeviceFull) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::ERROR_DEVICE_FULL).Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::ERROR_DEVICE_FULL)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(SavePageResult::DEVICE_FULL, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineArchiverContentUnavailable) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::ERROR_CONTENT_UNAVAILABLE).Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(
+          kTestUrl,
+          OfflinePageArchiver::ArchiverResult::ERROR_CONTENT_UNAVAILABLE)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(SavePageResult::CONTENT_UNAVAILABLE, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineCreationFailed) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::ERROR_ARCHIVE_CREATION_FAILED).
-          Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(
+          kTestUrl,
+          OfflinePageArchiver::ArchiverResult::ERROR_ARCHIVE_CREATION_FAILED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(SavePageResult::ARCHIVE_CREATION_FAILED, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineArchiverReturnedWrongUrl) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      GURL("http://other.random.url.com"), kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED).Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(GURL("http://other.random.url.com"),
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(SavePageResult::ARCHIVE_CREATION_FAILED, last_save_result());
 }
@@ -417,42 +417,45 @@ TEST_F(OfflinePageModelTest, SavePageOfflineArchiverReturnedWrongUrl) {
 TEST_F(OfflinePageModelTest, SavePageOfflineCreationStoreWriteFailure) {
   GetStore()->set_test_scenario(
       OfflinePageTestStore::TestScenario::WRITE_FAILED);
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED).Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(SavePageResult::STORE_FAILURE, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineArchiverTwoPages) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED).Pass());
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
   // archiver_ptr will be valid until after first PumpLoop() call after
   // CompleteCreateArchive() is called.
   OfflinePageTestArchiver* archiver_ptr = archiver.get();
   archiver_ptr->set_delayed(true);
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   EXPECT_TRUE(archiver_ptr->create_archive_called());
 
   // Request to save another page.
-  scoped_ptr<OfflinePageTestArchiver> archiver2(BuildArchiver(
-      kTestUrl2, kTestPageTitle2,
-      OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED).Pass());
-  model()->SavePage(kTestUrl2, archiver2.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver2(
+      BuildArchiver(kTestUrl2,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl2, kTestPageBookmarkId2, archiver2.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   OfflinePageTestStore* store = GetStore();
 
   EXPECT_EQ(kTestUrl2, store->last_saved_page().url);
-  EXPECT_EQ(kTestPageTitle2, store->last_saved_page().title);
+  EXPECT_EQ(kTestPageBookmarkId2, store->last_saved_page().bookmark_id);
   base::FilePath archiver_path2 = last_archiver_path();
   EXPECT_EQ(archiver_path2, store->last_saved_page().file_path);
   EXPECT_EQ(kTestFileSize, store->last_saved_page().file_size);
@@ -465,7 +468,7 @@ TEST_F(OfflinePageModelTest, SavePageOfflineArchiverTwoPages) {
   PumpLoop();
 
   EXPECT_EQ(kTestUrl, store->last_saved_page().url);
-  EXPECT_EQ(kTestPageTitle, store->last_saved_page().title);
+  EXPECT_EQ(kTestPageBookmarkId1, store->last_saved_page().bookmark_id);
   base::FilePath archiver_path = last_archiver_path();
   EXPECT_EQ(archiver_path, store->last_saved_page().file_path);
   EXPECT_EQ(kTestFileSize, store->last_saved_page().file_size);
@@ -479,11 +482,11 @@ TEST_F(OfflinePageModelTest, SavePageOfflineArchiverTwoPages) {
   EXPECT_EQ(LoadResult::SUCCESS, last_load_result());
   EXPECT_EQ(2UL, last_loaded_pages().size());
   EXPECT_EQ(kTestUrl2, last_loaded_pages()[0].url);
-  EXPECT_EQ(kTestPageTitle2, last_loaded_pages()[0].title);
+  EXPECT_EQ(kTestPageBookmarkId2, last_loaded_pages()[0].bookmark_id);
   EXPECT_EQ(archiver_path2, last_loaded_pages()[0].file_path);
   EXPECT_EQ(kTestFileSize, last_loaded_pages()[0].file_size);
   EXPECT_EQ(kTestUrl, last_loaded_pages()[1].url);
-  EXPECT_EQ(kTestPageTitle, last_loaded_pages()[1].title);
+  EXPECT_EQ(kTestPageBookmarkId1, last_loaded_pages()[1].bookmark_id);
   EXPECT_EQ(archiver_path, last_loaded_pages()[1].file_path);
   EXPECT_EQ(kTestFileSize, last_loaded_pages()[1].file_size);
 }
@@ -510,12 +513,13 @@ TEST_F(OfflinePageModelTest, DeletePageSuccessful) {
   OfflinePageTestStore* store = GetStore();
 
   // Save one page.
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED).Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   EXPECT_EQ(SavePageResult::SUCCESS, last_save_result());
@@ -524,12 +528,13 @@ TEST_F(OfflinePageModelTest, DeletePageSuccessful) {
   ResetResults();
 
   // Save another page.
-  scoped_ptr<OfflinePageTestArchiver> archiver2(BuildArchiver(
-      kTestUrl2, kTestPageTitle2,
-      OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED).Pass());
-  model()->SavePage(kTestUrl2, archiver2.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver2(
+      BuildArchiver(kTestUrl2,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl2, kTestPageBookmarkId2, archiver2.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   EXPECT_EQ(SavePageResult::SUCCESS, last_save_result());
@@ -581,12 +586,13 @@ TEST_F(OfflinePageModelTest, DeletePageNotFound) {
 
 TEST_F(OfflinePageModelTest, DeletePageStoreFailureOnRemove) {
   // Save a page.
-  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
-      kTestUrl, kTestPageTitle,
-      OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED).Pass());
-  model()->SavePage(kTestUrl, archiver.Pass(),
-                    base::Bind(&OfflinePageModelTest::OnSavePageDone,
-                               AsWeakPtr()));
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   ResetResults();
diff --git a/components/offline_pages/proto/offline_pages.proto b/components/offline_pages/proto/offline_pages.proto
index 16f23b1..07025a1 100644
--- a/components/offline_pages/proto/offline_pages.proto
+++ b/components/offline_pages/proto/offline_pages.proto
@@ -16,8 +16,8 @@ message OfflinePageEntry {
   // URL of the offline page.
   required string url = 1;
 
-  // Title of the offline page.
-  required string title = 2;
+  // Bookmark ID of the offline page.
+  required int64 bookmark_id = 2;
 
   // Version of the offline page metadata.
   required int32 version = 3;