Persist offline page info in a navigation entry if needed

components/sessions/content/content_serialized_navigation_builder_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sessions/content/content_serialized_navigation_builder.h"
 
+#include "base/memory/ptr_util.h"
 #include "components/sessions/content/content_record_password_state.h"
+#include "components/sessions/content/content_serialized_navigation_driver.h"
+#include "components/sessions/content/extended_info_handler.h"
 #include "components/sessions/core/serialized_navigation_entry.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/common/page_state.h"
 #include "content/public/common/referrer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sessions {
 
 namespace {
+
+const char kExtendedInfoKey1[] = "Key 1";
+const char kExtendedInfoValue1[] = "Value 1";
+const char kExtendedInfoKey2[] = "Key 2";
+const char kExtendedInfoValue2[] = "Value 2";
+
+class TestExtendedInfoHandler : public ExtendedInfoHandler {
+ public:
+  explicit TestExtendedInfoHandler(const std::string& value) : value_(value) {}
+  ~TestExtendedInfoHandler() override {}
+
+  std::string GetExtendedInfo(
+      const content::NavigationEntry& entry) const override {
+    return value_;
+  }
+
+  void RestoreExtendedInfo(
+      const std::string& info, content::NavigationEntry* entry) override {

[sky, 2016/09/29 03:08:19]

Write test coverage to ensure this is called too.

[jianli, 2016/09/29 22:02:29]

Done.

+  }
+
+ private:
+   std::string value_;
+};

[sky, 2016/09/29 03:08:19]

DISALLOW.
Also, run git cl format as your spacing looks off.

[jianli, 2016/09/29 22:02:29]

Done.

+
 // Create a NavigationEntry from the test_data constants in
 // serialized_navigation_entry_test_helper.h.
 std::unique_ptr<content::NavigationEntry> MakeNavigationEntryForTest() {
   std::unique_ptr<content::NavigationEntry> navigation_entry(
       content::NavigationEntry::Create());
   navigation_entry->SetReferrer(content::Referrer(
       test_data::kReferrerURL,
       static_cast<blink::WebReferrerPolicy>(test_data::kReferrerPolicy)));
   navigation_entry->SetVirtualURL(test_data::kVirtualURL);
   navigation_entry->SetTitle(test_data::kTitle);
@@ skipping 19 matching lines @@
   navigation_entry->SetRedirectChain(redirect_chain);
   return navigation_entry;
 }
 
 }  // namespace
 
 
 // Create a SerializedNavigationEntry from a NavigationEntry.  All its fields
 // should match the NavigationEntry's.
 TEST(ContentSerializedNavigationBuilderTest, FromNavigationEntry) {
+  ContentSerializedNavigationDriver::GetInstance()->RegisterExtendedInfoHandler(
+      kExtendedInfoKey1,
+      base::WrapUnique<ExtendedInfoHandler>(
+          new TestExtendedInfoHandler(kExtendedInfoValue1)));
+  ContentSerializedNavigationDriver::GetInstance()->RegisterExtendedInfoHandler(
+      kExtendedInfoKey2,
+      base::WrapUnique<ExtendedInfoHandler>(
+          new TestExtendedInfoHandler(kExtendedInfoValue2)));
+
   const std::unique_ptr<content::NavigationEntry> navigation_entry(
       MakeNavigationEntryForTest());
 
   const SerializedNavigationEntry& navigation =
       ContentSerializedNavigationBuilder::FromNavigationEntry(
           test_data::kIndex, *navigation_entry);
 
   EXPECT_EQ(test_data::kIndex, navigation.index());
 
   EXPECT_EQ(navigation_entry->GetUniqueID(), navigation.unique_id());
@@ skipping 10 matching lines @@
   EXPECT_EQ(test_data::kIsOverridingUserAgent,
             navigation.is_overriding_user_agent());
   EXPECT_EQ(test_data::kTimestamp, navigation.timestamp());
   EXPECT_EQ(test_data::kFaviconURL, navigation.favicon_url());
   EXPECT_EQ(test_data::kHttpStatusCode, navigation.http_status_code());
   ASSERT_EQ(3U, navigation.redirect_chain().size());
   EXPECT_EQ(test_data::kRedirectURL0, navigation.redirect_chain()[0]);
   EXPECT_EQ(test_data::kRedirectURL1, navigation.redirect_chain()[1]);
   EXPECT_EQ(test_data::kVirtualURL, navigation.redirect_chain()[2]);
   EXPECT_EQ(test_data::kPasswordState, navigation.password_state());
+
+  ASSERT_EQ(2U, navigation.extended_info_map().size());
+  ASSERT_EQ(1U, navigation.extended_info_map().count(kExtendedInfoKey1));
+  EXPECT_EQ(kExtendedInfoValue1,
+            navigation.extended_info_map().at(kExtendedInfoKey1));
+  ASSERT_EQ(1U, navigation.extended_info_map().count(kExtendedInfoKey2));
+  EXPECT_EQ(kExtendedInfoValue2,
+            navigation.extended_info_map().at(kExtendedInfoKey2));
 }
 
 // Create a NavigationEntry, then create another one by converting to
 // a SerializedNavigationEntry and back.  The new one should match the old one
 // except for fields that aren't preserved, which should be set to
 // expected values.
 TEST(ContentSerializedNavigationBuilderTest, ToNavigationEntry) {
   const std::unique_ptr<content::NavigationEntry> old_navigation_entry(
       MakeNavigationEntryForTest());
 
@@ skipping 41 matching lines @@
 
   EXPECT_EQ(SerializedNavigationEntry::PASSWORD_STATE_UNKNOWN,
             GetPasswordStateFromNavigation(*entry));
   SetPasswordStateInNavigation(SerializedNavigationEntry::NO_PASSWORD_FIELD,
                                entry.get());
   EXPECT_EQ(SerializedNavigationEntry::NO_PASSWORD_FIELD,
             GetPasswordStateFromNavigation(*entry));
 }
 
 }  // namespace sessions