CRWSessionEntry: Replaced hardcoded strings with constants.

ios/web/navigation/crw_session_entry.mm

 // Copyright 2012 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.
 
 #import "ios/web/navigation/crw_session_entry.h"
 
 #include "base/mac/objc_property_releaser.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/sys_string_conversions.h"
 #include "ios/web/navigation/navigation_item_impl.h"
 #include "ios/web/navigation/nscoder_util.h"
 #include "ios/web/public/navigation_item.h"
 #include "ios/web/public/web_state/page_scroll_state.h"
 #import "net/base/mac/url_conversions.h"
 
-namespace {
+namespace web {
 // Keys used to serialize web::PageScrollState properties.
+NSString* const kPageScrollStateKey = @"state";
 NSString* const kScrollOffsetXKey = @"scrollX";
 NSString* const kScrollOffsetYKey = @"scrollY";
 NSString* const kMinimumZoomScaleKey = @"minZoom";
 NSString* const kMaximumZoomScaleKey = @"maxZoom";
 NSString* const kZoomScaleKey = @"zoom";
+
+// Keys used to serialize navigation properties.
+NSString* const kURLKey = @"virtualUrlString";
+NSString* const kURLDeperecatedKey = @"virtualUrl";
+NSString* const kReferrerURLKey = @"referrerUrlString";
+NSString* const kReferrerURLDeprecatedKey = @"referrer";
+NSString* const kReferrerPolicyKey = @"referrerPolicy";
+NSString* const kTimestampKey = @"timestamp";
+NSString* const kTitleKey = @"title";
+NSString* const kPOSTDataKey = @"POSTData";
+NSString* const kHTTPRequestHeadersKey = @"httpHeaders";
+NSString* const kSkipResubmitConfirmationKey = @"skipResubmitDataConfirmation";
+NSString* const kUseDesktopUserAgentKey = @"useDesktopUserAgent";
 }
 
 @interface CRWSessionEntry () {
   // The original URL of the page.  In cases where a redirect occurred, |url_|
   // will contain the final post-redirect URL, and |originalUrl_| will contain
   // the pre-redirect URL.  This field is not persisted to disk.
   GURL _originalUrl;
 
   // The NavigationItemImpl corresponding to this CRWSessionEntry.
   // TODO(stuartmorgan): Move ownership to NavigationManagerImpl.
@@ skipping 30 matching lines @@
 
 - (instancetype)initWithCoder:(NSCoder*)aDecoder {
   self = [super init];
   if (self) {
     _propertyReleaser_CRWSessionEntry.Init(self, [CRWSessionEntry class]);
     _navigationItem.reset(new web::NavigationItemImpl());
 
     // Desktop chrome only persists virtualUrl_ and uses it to feed the url
     // when creating a NavigationEntry.
     GURL url;
-    if ([aDecoder containsValueForKey:@"virtualUrlString"]) {
-      url = GURL(
-          web::nscoder_util::DecodeString(aDecoder, @"virtualUrlString"));
+    if ([aDecoder containsValueForKey:web::kURLKey]) {
+      url = GURL(web::nscoder_util::DecodeString(aDecoder, web::kURLKey));
     } else {
       // Backward compatibility.
-      url = net::GURLWithNSURL([aDecoder decodeObjectForKey:@"virtualUrl"]);
+      url = net::GURLWithNSURL(
+          [aDecoder decodeObjectForKey:web::kURLDeperecatedKey]);
     }
     _navigationItem->SetURL(url);
     self.originalUrl = url;
 
-    if ([aDecoder containsValueForKey:@"referrerUrlString"]) {
-      const std::string referrerString(web::nscoder_util::DecodeString(
-          aDecoder, @"referrerUrlString"));
-      web::ReferrerPolicy referrerPolicy =
-          static_cast<web::ReferrerPolicy>(
-              [aDecoder decodeIntForKey:@"referrerPolicy"]);
+    if ([aDecoder containsValueForKey:web::kReferrerURLKey]) {
+      const std::string referrerString(
+          web::nscoder_util::DecodeString(aDecoder, web::kReferrerURLKey));
+      web::ReferrerPolicy referrerPolicy = static_cast<web::ReferrerPolicy>(
+          [aDecoder decodeIntForKey:web::kReferrerPolicyKey]);
       _navigationItem->SetReferrer(
           web::Referrer(GURL(referrerString), referrerPolicy));
     } else {
       // Backward compatibility.
-      NSURL* referrer = [aDecoder decodeObjectForKey:@"referrer"];
+      NSURL* referrer =
+          [aDecoder decodeObjectForKey:web::kReferrerURLDeprecatedKey];
       _navigationItem->SetReferrer(web::Referrer(
           net::GURLWithNSURL(referrer), web::ReferrerPolicyDefault));
     }
 
-    if ([aDecoder containsValueForKey:@"timestamp"]) {
-      int64 us = [aDecoder decodeInt64ForKey:@"timestamp"];
+    if ([aDecoder containsValueForKey:web::kTimestampKey]) {
+      int64 us = [aDecoder decodeInt64ForKey:web::kTimestampKey];
       _navigationItem->SetTimestamp(base::Time::FromInternalValue(us));
     }
 
-    NSString* title = [aDecoder decodeObjectForKey:@"title"];
+    NSString* title = [aDecoder decodeObjectForKey:web::kTitleKey];
     // Use a transition type of reload so that we don't incorrectly increase
     // the typed count.  This is what desktop chrome does.
     _navigationItem->SetPageID(-1);
     _navigationItem->SetTitle(base::SysNSStringToUTF16(title));
     _navigationItem->SetTransitionType(ui::PAGE_TRANSITION_RELOAD);
     _navigationItem->SetPageScrollState([[self class]
-        scrollStateFromDictionary:[aDecoder decodeObjectForKey:@"state"]]);
+        scrollStateFromDictionary:
+            [aDecoder decodeObjectForKey:web::kPageScrollStateKey]]);
     _navigationItem->SetShouldSkipResubmitDataConfirmation(
-        [aDecoder decodeBoolForKey:@"skipResubmitDataConfirmation"]);
+        [aDecoder decodeBoolForKey:web::kSkipResubmitConfirmationKey]);
     _navigationItem->SetIsOverridingUserAgent(
-        [aDecoder decodeBoolForKey:@"useDesktopUserAgent"]);
-    _navigationItem->SetPostData([aDecoder decodeObjectForKey:@"POSTData"]);
+        [aDecoder decodeBoolForKey:web::kUseDesktopUserAgentKey]);
+    _navigationItem->SetPostData(
+        [aDecoder decodeObjectForKey:web::kPOSTDataKey]);
     _navigationItem->AddHttpRequestHeaders(
-        [aDecoder decodeObjectForKey:@"httpHeaders"]);
+        [aDecoder decodeObjectForKey:web::kHTTPRequestHeadersKey]);
   }
   return self;
 }
 
 - (void)encodeWithCoder:(NSCoder*)aCoder {
   // Desktop Chrome doesn't persist |url_| or |originalUrl_|, only
   // |virtualUrl_|.
-  web::nscoder_util::EncodeString(aCoder, @"virtualUrlString",
+  web::nscoder_util::EncodeString(aCoder, web::kURLKey,
                                   _navigationItem->GetVirtualURL().spec());
-  web::nscoder_util::EncodeString(aCoder, @"referrerUrlString",
+  web::nscoder_util::EncodeString(aCoder, web::kReferrerURLKey,
                                   _navigationItem->GetReferrer().url.spec());
   [aCoder encodeInt:_navigationItem->GetReferrer().policy
-             forKey:@"referrerPolicy"];
+             forKey:web::kReferrerPolicyKey];
   [aCoder encodeInt64:_navigationItem->GetTimestamp().ToInternalValue()
-               forKey:@"timestamp"];
+               forKey:web::kTimestampKey];
 
   [aCoder encodeObject:base::SysUTF16ToNSString(_navigationItem->GetTitle())
-                forKey:@"title"];
+                forKey:web::kTitleKey];
   [aCoder encodeObject:[[self class] dictionaryFromScrollState:
                                          _navigationItem->GetPageScrollState()]
-                forKey:@"state"];
+                forKey:web::kPageScrollStateKey];
   [aCoder encodeBool:_navigationItem->ShouldSkipResubmitDataConfirmation()
-              forKey:@"skipResubmitDataConfirmation"];
+              forKey:web::kSkipResubmitConfirmationKey];
   [aCoder encodeBool:_navigationItem->IsOverridingUserAgent()
-              forKey:@"useDesktopUserAgent"];
-  [aCoder encodeObject:_navigationItem->GetPostData() forKey:@"POSTData"];
+              forKey:web::kUseDesktopUserAgentKey];
+  [aCoder encodeObject:_navigationItem->GetPostData() forKey:web::kPOSTDataKey];
   [aCoder encodeObject:_navigationItem->GetHttpRequestHeaders()
-                forKey:@"httpHeaders"];
+                forKey:web::kHTTPRequestHeadersKey];
 }
 
 // TODO(ios): Shall we overwrite EqualTo:?
 
 - (instancetype)copyWithZone:(NSZone*)zone {
   CRWSessionEntry* copy = [[[self class] alloc] init];
   copy->_propertyReleaser_CRWSessionEntry.Init(copy, [CRWSessionEntry class]);
   copy->_navigationItem.reset(
       new web::NavigationItemImpl(*_navigationItem.get()));
   copy->_originalUrl = _originalUrl;
@@ skipping 20 matching lines @@
 
 - (web::NavigationItemImpl*)navigationItemImpl {
   return _navigationItem.get();
 }
 
 #pragma mark - Serialization helpers
 
 + (web::PageScrollState)scrollStateFromDictionary:(NSDictionary*)dictionary {
   web::PageScrollState scrollState;
   NSNumber* serializedValue = nil;
-  if ((serializedValue = dictionary[kScrollOffsetXKey]))
+  if ((serializedValue = dictionary[web::kScrollOffsetXKey]))
     scrollState.set_scroll_offset_x([serializedValue doubleValue]);
-  if ((serializedValue = dictionary[kScrollOffsetYKey]))
+  if ((serializedValue = dictionary[web::kScrollOffsetYKey]))
     scrollState.set_scroll_offset_y([serializedValue doubleValue]);
-  if ((serializedValue = dictionary[kMinimumZoomScaleKey]))
+  if ((serializedValue = dictionary[web::kMinimumZoomScaleKey]))
     scrollState.set_minimum_zoom_scale([serializedValue doubleValue]);
-  if ((serializedValue = dictionary[kMaximumZoomScaleKey]))
+  if ((serializedValue = dictionary[web::kMaximumZoomScaleKey]))
     scrollState.set_maximum_zoom_scale([serializedValue doubleValue]);
-  if ((serializedValue = dictionary[kZoomScaleKey]))
+  if ((serializedValue = dictionary[web::kZoomScaleKey]))
     scrollState.set_zoom_scale([serializedValue doubleValue]);
   return scrollState;
 }
 
 + (NSDictionary*)dictionaryFromScrollState:
     (const web::PageScrollState&)scrollState {
   return @{
-    kScrollOffsetXKey : @(scrollState.scroll_offset_x()),
-    kScrollOffsetYKey : @(scrollState.scroll_offset_y()),
-    kMinimumZoomScaleKey : @(scrollState.minimum_zoom_scale()),
-    kMaximumZoomScaleKey : @(scrollState.maximum_zoom_scale()),
-    kZoomScaleKey : @(scrollState.zoom_scale())
+    web::kScrollOffsetXKey : @(scrollState.scroll_offset_x()),
+    web::kScrollOffsetYKey : @(scrollState.scroll_offset_y()),
+    web::kMinimumZoomScaleKey : @(scrollState.minimum_zoom_scale()),
+    web::kMaximumZoomScaleKey : @(scrollState.maximum_zoom_scale()),
+    web::kZoomScaleKey : @(scrollState.zoom_scale()),
   };
 }
 
 + (NSString*)scrollStateDescription:(const web::PageScrollState&)scrollState {
   NSString* const kPageScrollStateDescriptionFormat =
       @"{ scrollOffset:(%0.2f, %0.2f), zoomScaleRange:(%0.2f, %0.2f), "
       @"zoomScale:%0.2f }";
   return [NSString stringWithFormat:kPageScrollStateDescriptionFormat,
                                     scrollState.scroll_offset_x(),
                                     scrollState.scroll_offset_y(),
                                     scrollState.minimum_zoom_scale(),
                                     scrollState.maximum_zoom_scale(),
                                     scrollState.zoom_scale()];
 }
 
 @end