Added logic that will return the result of the first chunk of root feed and continue fetching the r…

chrome/browser/chromeos/gdata/gdata_file_system.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/gdata/gdata_file_system.h"
 
 #include <errno.h>
 
 #include <utility>
 
@@ skipping 1438 matching lines @@
            base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED, FilePath(),
                reinterpret_cast<GDataFileBase*>(NULL)));
     }
 
     return;
   }
 
   // Add the current feed to the list of collected feeds for this directory.
   feed_list->Append(data.release());
 
-  // Check if we need to collect more data to complete the directory list.
-  if (current_feed->GetNextFeedURL(&next_feed_url) &&
-      !next_feed_url.is_empty()) {
+  bool initial_read = false;
+  {
+    base::AutoLock lock(lock_);
+    initial_read = root_->origin() == UNINITIALIZED;
+  }
+
+  bool has_more_data = current_feed->GetNextFeedURL(&next_feed_url) &&
+                       !next_feed_url.is_empty();
+
+  // If we are completely done with feed content fetching or if this is initial
+  // batch of content feed, we might want to update |root_| content and report

[satorux1, 2012/03/25 17:28:27]

nit: to make it very clear, we might want to describe the motivation here.

initial batch of content feed so that we can show the initial set of files to
the user as soon as the first chunk arrives, rather than waiting for the last
chunk to arrive (this can take quite some time if the user has 25K files for
instance).

[zel, 2012/03/25 17:39:20]

Done.

+  // on it.
+  if (initial_read || !has_more_data) {
+    error = UpdateDirectoryWithDocumentFeed(feed_list.get(),
+                                            FROM_SERVER);
+    if (error != base::PLATFORM_FILE_OK) {
+      if (!callback.is_null()) {
+        proxy->PostTask(FROM_HERE,
+             base::Bind(callback, error, FilePath(),
+                 reinterpret_cast<GDataFileBase*>(NULL)));
+      }
+
+      return;
+    }
+
+    // If we had someone to report this too, then this retrieval was done in a
+    // context of search... so continue search.
+    if (!callback.is_null()) {
+      proxy->PostTask(FROM_HERE,
+          base::Bind(&GDataFileSystem::FindFileByPathOnCallingThread,
+                     GetWeakPtrForCurrentThread(),
+                     search_file_path,
+                     callback));
+    }
+  }
+
+  if (has_more_data) {
+    // Don't report to initial callback if we were fetching the first chunk of
+    // uninitialized root feed, because we already reported. Instead, just
+    // continue with entire feed fetch in backgorund.
+    const FindFileCallback continue_callback =
+        initial_read ? FindFileCallback() : callback;
     // Kick of the remaining part of the feeds.
     documents_service_->GetDocuments(
         next_feed_url,
         base::Bind(&GDataFileSystem::OnGetDocuments,
                    GetWeakPtrForCurrentThread(),
                    search_file_path,
                    base::Passed(&feed_list),
                    proxy,
-                   callback));
-    return;
-  }
-
-  error = UpdateDirectoryWithDocumentFeed(feed_list.get(), FROM_SERVER);
-  if (error != base::PLATFORM_FILE_OK) {
-    if (!callback.is_null()) {
-      proxy->PostTask(FROM_HERE,
-           base::Bind(callback, error, FilePath(),
-               reinterpret_cast<GDataFileBase*>(NULL)));
-    }
-
-    return;
-  }
-
-  scoped_ptr<base::Value> feed_list_value(feed_list.release());
-  SaveFeed(feed_list_value.Pass(), FilePath(kLastFeedFile));
-
-  // If we had someone to report this too, then this retrieval was done in a
-  // context of search... so continue search.
-  if (!callback.is_null()) {
-    proxy->PostTask(FROM_HERE,
-                    base::Bind(&GDataFileSystem::FindFileByPathOnCallingThread,
-                               GetWeakPtrForCurrentThread(),
-                               search_file_path,
-                               callback));
+                   continue_callback));
+  } else {
+    // Save completed feed in meta cache.
+    scoped_ptr<base::Value> feed_list_value(feed_list.release());
+    SaveFeed(feed_list_value.Pass(), FilePath(kLastFeedFile));
   }
 }
 
 void GDataFileSystem::LoadRootFeedFromCache(
     const FilePath& search_file_path,
     bool load_from_server,
     scoped_refptr<base::MessageLoopProxy> proxy,
     const FindFileCallback& callback) {
   BrowserThread::PostBlockingPoolTask(FROM_HERE,
       base::Bind(&GDataFileSystem::LoadRootFeedOnIOThreadPool,
@@ skipping 446 matching lines @@
       GURL parent_url;
       const Link* parent_link = doc->GetLinkByType(Link::PARENT);
       if (parent_link)
         parent_url = parent_link->href();
 
       UrlToFileAndParentMap::mapped_type& map_entry =
           file_by_url[file->self_url()];
       // An entry with the same self link may already exist, so we need to
       // release the existing GDataFileBase instance before overwriting the
       // entry with another GDataFileBase instance.
+      if (map_entry.first) {
+        LOG(WARNING) << "Found duplicate file "
+                     << map_entry.first->file_name();
+      }
+
       delete map_entry.first;
       map_entry.first = file;
       map_entry.second = parent_url;
     }
   }
 
   if (error != base::PLATFORM_FILE_OK) {
     // If the code above fails to parse a feed, any GDataFileBase instance
     // added to |file_by_url| is not managed by a GDataDirectory instance,
     // so we need to explicitly release them here.
     for (UrlToFileAndParentMap::iterator it = file_by_url.begin();
          it != file_by_url.end(); ++it) {
       delete it->second.first;
     }
     return error;
   }
 
+  scoped_ptr<GDataRootDirectory> orphaned_files(new GDataRootDirectory(NULL));
   for (UrlToFileAndParentMap::iterator it = file_by_url.begin();
        it != file_by_url.end(); ++it) {
     scoped_ptr<GDataFileBase> file(it->second.first);
     GURL parent_url = it->second.second;
     GDataDirectory* dir = root_.get();
     if (!parent_url.is_empty()) {
-      UrlToFileAndParentMap::iterator find_iter = file_by_url.find(parent_url);
+      UrlToFileAndParentMap::const_iterator find_iter =
+          file_by_url.find(parent_url);
       if (find_iter == file_by_url.end()) {
-        LOG(WARNING) << "Found orphaned file '" << file->file_name()
-                     << "' with non-existing parent folder of "
-                     << parent_url.spec();
+        DVLOG(1) << "Found orphaned file '" << file->file_name()
+                 << "' with non-existing parent folder of "
+                 << parent_url.spec();
+        dir = orphaned_files.get();
       } else {
-        dir = find_iter->second.first->AsGDataDirectory();
+        dir = find_iter->second.first ?
+              find_iter->second.first->AsGDataDirectory() : NULL;
         if (!dir) {
-          LOG(WARNING) << "Found orphaned file '" << file->file_name()
-                       << "' pointing to non directory parent "
-                       << parent_url.spec();
-          dir = root_.get();
+          DVLOG(1) << "Found orphaned file '" << file->file_name()
+                   << "' pointing to non directory parent "
+                   << parent_url.spec();
+          dir = orphaned_files.get();
         }
       }
     }
-    DCHECK(dir);
-
     dir->AddFile(file.release());
   }
 
   if (should_nofify)
     NotifyDirectoryChanged(root_->GetFilePath());
 
   return base::PLATFORM_FILE_OK;
 }
 
 void GDataFileSystem::NotifyCacheInitialized() {
@@ skipping 1305 matching lines @@
   const bool posted = BrowserThread::PostBlockingPoolSequencedTask(
       sequence_token_name,
       from_here,
       base::Bind(&GDataFileSystem::RunTaskOnIOThreadPool,
                  base::Unretained(this),
                  task));
   DCHECK(posted);
 }
 
 }  // namespace gdata