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 1537 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 so that we can show the initial set of files to
+  // the user as soon as the first chunk arrives, rather than waiting for all
+  // chunk to arrive.
+  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