[rac] Use stale libaddressinput data if download fails

third_party/libaddressinput/chromium/cpp/src/validating_util.h

 // Copyright (C) 2013 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 13 matching lines @@
 
 namespace i18n {
 namespace addressinput {
 
 // Wraps data with a checksum and a timestamp. Sample usage:
 //    std::string data  = ...
 //    std::string wrapped = ValidatingUtil::Wrap(data, time(NULL));
 //    Process(wrapped);
 //
 //    std::string unwrapped = wrapped;
-//    if (ValidatingUtil::UnwrapTimestamp(&unwrapped, time(NULL)) &&
+//    if (ValidatingUtil::TIMESTAMP_VALID ==
+//            ValidatingUtil::UnwrapTimestamp(&unwrapped, time(NULL)) &&
 //        ValidatingUtil::UnwrapChecksum(&unwrapped)) {
 //      Process(unwrapped);
 //    }
 class ValidatingUtil {
  public:
+  // Result of parsing and validating a timestamp.
+  enum TimestampStatus {
+   // The timestamp is present, formatted correctly, valid, and recent.
+    TIMESTAMP_VALID,
+
+    // The timestamp is either missing, incorrectly formatted, or invalid.
+    TIMESTAMP_INVALID,
+
+    // The timestamp is present, formatted correctly, and valid, but stale.
+    TIMESTAMP_STALE
+  };
+
   // Returns |data| with attached checksum and given |timestamp|.
   static std::string Wrap(const std::string& data, time_t timestamp);
 
-  // Strips out the timestamp from |data|. Returns |true| if the timestamp is
-  // present, formatted correctly, valid, and recent with respect to |now|.
-  static bool UnwrapTimestamp(std::string* data, time_t now);
+  // Strips out the timestamp from |data| and validates it with respect to
+  // |now|.
+  static TimestampStatus UnwrapTimestamp(std::string* data, time_t now);

[Evan Stade, 2014/01/22 01:42:12]

I think that UnwrapTimestamp and UnwrapChecksum should be a single function:

static bool UnwrapHeader(const std::string& header, time_t* timestamp);

that returns false if the timestamp is missing or invalid or if the checksum
doesn't validate or is missing or anything, but otherwise returns true and fills
out timestamp. The Retriever can contain the logic of "how old is too old".

[please use gerrit instead, 2014/01/22 23:57:41]

Refactored into:

std::string Wrapper::Wrap(const std::string& data);
bool Wrapper::Unwrap(std::string* data, double* age_in_seconds);

I think that's an improvement on what you suggested, because it hides the time_t
inside of the Wrapper implementation. The logic of "how old is too old" in
Retriever is simple now: compare age_in_seconds to the maximum allowed age.

[Evan Stade, 2014/01/23 00:07:23]

why is double a better way of representing time than time_t?

[please use gerrit instead, 2014/01/23 00:09:00]

The difference between two time_t objects is always a double:

http://www.cplusplus.com/reference/ctime/difftime/

 
-  // Strips out the checksum from |data|. Returns |true| if the checksum is
-  // present, formatted correctly, and valid for this data.
+  // Strips out and validates the checksum from |data|. Returns |true| if the
+  // checksum is present, formatted correctly, and valid for this data.
   static bool UnwrapChecksum(std::string* data);
 };
 
 }  // namespace addressinput
 }  // namespace i18n
 
 #endif  // I18N_ADDRESSINPUT_VALIDATING_UTIL_H_