Use int64 time stamp when storing metadata to the HTTP cache.

net/http/http_cache.cc

 // Copyright (c) 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.
 
 #include "net/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 194 matching lines @@
   explicit MetadataWriter(HttpCache::Transaction* trans)
       : transaction_(trans),
         verified_(false),
         buf_len_(0) {
   }
 
   ~MetadataWriter() {}
 
   // Implements the bulk of HttpCache::WriteMetadata.
   void Write(const GURL& url,
-             double expected_response_time,
+             base::Time expected_response_time,
              IOBuffer* buf,
              int buf_len);
 
  private:
   void VerifyResponse(int result);
   void SelfDestroy();
   void OnIOComplete(int result);
 
   scoped_ptr<HttpCache::Transaction> transaction_;
   bool verified_;
   scoped_refptr<IOBuffer> buf_;
   int buf_len_;
-  double expected_response_time_;
+  base::Time expected_response_time_;
   HttpRequestInfo request_info_;
   DISALLOW_COPY_AND_ASSIGN(MetadataWriter);
 };
 
 void HttpCache::MetadataWriter::Write(const GURL& url,
-                                      double expected_response_time,
+                                      base::Time expected_response_time,
                                       IOBuffer* buf,
                                       int buf_len) {
   DCHECK_GT(buf_len, 0);
   DCHECK(buf);
   DCHECK(buf->data());
   request_info_.url = url;
   request_info_.method = "GET";
   request_info_.load_flags = LOAD_ONLY_FROM_CACHE;
 
   expected_response_time_ = expected_response_time;
   buf_ = buf;
   buf_len_ = buf_len;
   verified_ = false;
 
   int rv = transaction_->Start(
       &request_info_,
       base::Bind(&MetadataWriter::OnIOComplete, base::Unretained(this)),
       BoundNetLog());
   if (rv != ERR_IO_PENDING)
     VerifyResponse(rv);
 }
 
 void HttpCache::MetadataWriter::VerifyResponse(int result) {
   verified_ = true;
   if (result != OK)
     return SelfDestroy();
 
   const HttpResponseInfo* response_info = transaction_->GetResponseInfo();
   DCHECK(response_info->was_cached);
-  if (response_info->response_time.ToDoubleT() != expected_response_time_)
+  if (response_info->response_time != expected_response_time_)
     return SelfDestroy();
 
   result = transaction_->WriteMetadata(
       buf_.get(),
       buf_len_,
       base::Bind(&MetadataWriter::OnIOComplete, base::Unretained(this)));
   if (result != ERR_IO_PENDING)
     SelfDestroy();
 }
 
@@ skipping 297 matching lines @@
 // static
 bool HttpCache::ParseResponseInfo(const char* data, int len,
                                   HttpResponseInfo* response_info,
                                   bool* response_truncated) {
   Pickle pickle(data, len);
   return response_info->InitFromPickle(pickle, response_truncated);
 }
 
 void HttpCache::WriteMetadata(const GURL& url,
                               RequestPriority priority,
-                              double expected_response_time,
+                              base::Time expected_response_time,
                               IOBuffer* buf,
                               int buf_len) {
   if (!buf_len)
     return;
 
   // Do lazy initialization of disk cache if needed.
   if (!disk_cache_.get()) {
     // We don't care about the result.
     CreateBackend(NULL, net::CompletionCallback());
   }
@@ skipping 825 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net