drive: prefetcher compares last modified time in addition to last access time.

chrome/browser/chromeos/drive/drive_prefetcher.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 "chrome/browser/chromeos/drive/drive_prefetcher.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
-#include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace drive {
 
 namespace {
 
 const int kInitialPrefetchCount = 100;
 const int64 kPrefetchFileSizeLimit = 10 << 20;  // 10MB
 
 // Returns true if prefetching is disabled by a command line option.
 bool IsPrefetchDisabled() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableDrivePrefetch);
 }
 
+// Returns true if |left| has lower priority than |right|.
+bool ComparePrefetchPriority(const DriveEntryProto& left,
+                             const DriveEntryProto& right) {
+  // First, compare last access time. The older entry has less priority.
+  if (left.file_info().last_accessed() != right.file_info().last_accessed())
+    return left.file_info().last_accessed() < right.file_info().last_accessed();
+
+  // When the entries have the same last access time (which happens quite often
+  // because Drive server doesn't set the field until an entry is viewed via
+  // drive.google.com), we use last modified time as the tie breaker.
+  if (left.file_info().last_modified() != right.file_info().last_modified())
+    return left.file_info().last_modified() < right.file_info().last_modified();
+
+  // Two entries have the same priority. To make this function a valid
+  // comparator for std::set, we need to differentiate them anyhow.
+  return left.resource_id() < right.resource_id();
+}
+
 }
 
 DrivePrefetcherOptions::DrivePrefetcherOptions()
     : initial_prefetch_count(kInitialPrefetchCount),
       prefetch_file_size_limit(kPrefetchFileSizeLimit) {
 }
 
 DrivePrefetcher::DrivePrefetcher(DriveFileSystemInterface* file_system,
                                  const DrivePrefetcherOptions& options)
-    : number_of_inflight_prefetches_(0),
+    : latest_files_(&ComparePrefetchPriority),
+      number_of_inflight_prefetches_(0),
       number_of_inflight_traversals_(0),
       should_suspend_prefetch_(true),
       initial_prefetch_count_(options.initial_prefetch_count),
       prefetch_file_size_limit_(options.prefetch_file_size_limit),
       file_system_(file_system),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   file_system_->AddObserver(this);
 }
 
@@ skipping 72 matching lines @@
   DoPrefetch();  // Start next prefetch.
 }
 
 void DrivePrefetcher::ReconstructQueue() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Put the files with latest timestamp into the queue.
   queue_.clear();
   for (LatestFileSet::reverse_iterator it = latest_files_.rbegin();
       it != latest_files_.rend(); ++it) {
-    queue_.push_back(it->second);
+    queue_.push_back(it->resource_id());
   }
 }
 
 void DrivePrefetcher::VisitFile(const DriveEntryProto& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  int64 last_access = entry.file_info().last_accessed();
-  const std::string& resource_id = entry.resource_id();
-
   // Excessively large files will not be fetched.
   if (entry.file_info().size() > prefetch_file_size_limit_)
     return;
 
   // Remember the file in the set ordered by the |last_accessed| field.
-  latest_files_.insert(std::make_pair(last_access, resource_id));
+  latest_files_.insert(entry);
   // If the set become too big, forget the oldest entry.
   if (latest_files_.size() > static_cast<size_t>(initial_prefetch_count_))
     latest_files_.erase(latest_files_.begin());
 }
 
 void DrivePrefetcher::VisitDirectory(const FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ++number_of_inflight_traversals_;
   file_system_->ReadDirectoryByPath(
@@ skipping 38 matching lines @@
   DCHECK(number_of_inflight_traversals_ > 0);
 
   --number_of_inflight_traversals_;
   if (number_of_inflight_traversals_ == 0) {
     ReconstructQueue();
     DoPrefetch();  // Start prefetching.
   }
 }
 
 }  // namespace drive