gdata: Remove NotifyDirectoryChanged() and NotifyDocumentFeedFetched()

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 <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 2374 matching lines @@
     scoped_ptr<GDataEntry> entry(it->second);
     // Skip if it's not a file (i.e. directory).
     if (!entry->AsGDataFile())
       continue;
     directory->AddEntry(entry.release());
   }
 
   // Note that there may be no change in the directory, but it's expensive to
   // check if the new metadata matches the existing one, so we just always
   // notify that the directory is changed.
-  NotifyDirectoryChanged(directory_path);
+  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(directory_path));
   DVLOG(1) << "Directory refreshed: " << directory_path.value();
 }
 
 void GDataFileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::UpdateFileByResourceIdOnUIThread,
@@ skipping 377 matching lines @@
                  base::Passed(&data)));
 #endif
 
   // Add the current feed to the list of collected feeds for this directory.
   params->feed_list->push_back(current_feed.release());
 
   // Compute and notify the number of entries fetched so far.
   int num_accumulated_entries = 0;
   for (size_t i = 0; i < params->feed_list->size(); ++i)
     num_accumulated_entries += params->feed_list->at(i)->entries().size();
-  NotifyDocumentFeedFetched(num_accumulated_entries);
+
+  // Notify the observers that a document feed is fetched.
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnDocumentFeedFetched(num_accumulated_entries));
 
   // Check if we need to collect more data to complete the directory list.
   if (params->should_fetch_multiple_feeds && has_next_feed_url &&
       !next_feed_url.is_empty()) {
     // Kick of the remaining part of the feeds.
     documents_service_->GetDocuments(
         next_feed_url,
         params->start_changestamp,
         params->search_query,
         params->directory_resource_id,
@@ skipping 377 matching lines @@
   // through the file name de-duplication.
   // TODO(achuith/satorux/zel): This code is fragile. The title has been
   // changed, but not the file_name. TakeEntry removes the child based on the
   // old file_name, and then re-adds the child by first assigning the new title
   // to file_name. http://crbug.com/30157
   if (!entry->parent()->TakeEntry(entry))
     return GDATA_FILE_ERROR_FAILED;
 
   *updated_file_path = entry->GetFilePath();
 
-  NotifyDirectoryChanged(updated_file_path->DirName());
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnDirectoryChanged(updated_file_path->DirName()));
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::AddEntryToDirectoryOnFilesystem(
     GDataEntry* entry, const FilePath& dir_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry);
 
   GDataEntry* dir_entry = directory_service_->FindEntryByPathSync(dir_path);
   if (!dir_entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   GDataDirectory* dir = dir_entry->AsGDataDirectory();
   if (!dir)
     return GDATA_FILE_ERROR_NOT_A_DIRECTORY;
 
   if (!dir->TakeEntry(entry))
     return GDATA_FILE_ERROR_FAILED;
 
-  NotifyDirectoryChanged(dir_path);
+  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(dir_path));
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::RemoveEntryFromDirectoryOnFilesystem(
     const FilePath& file_path, const FilePath& dir_path,
     FilePath* updated_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(updated_file_path);
 
   GDataEntry* entry = directory_service_->FindEntryByPathSync(file_path);
   if (!entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   GDataEntry* dir = directory_service_->FindEntryByPathSync(dir_path);
   if (!dir)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   if (!dir->AsGDataDirectory())
     return GDATA_FILE_ERROR_NOT_A_DIRECTORY;
 
   DCHECK_EQ(dir->AsGDataDirectory(), entry->parent());
 
   if (!directory_service_->root()->TakeEntry(entry))
     return GDATA_FILE_ERROR_FAILED;
 
   *updated_file_path = entry->GetFilePath();
 
-  NotifyDirectoryChanged(updated_file_path->DirName());
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnDirectoryChanged(updated_file_path->DirName()));
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::RemoveEntryFromFileSystem(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string resource_id;
   GDataFileError error = RemoveEntryFromGData(file_path, &resource_id);
   if (error != GDATA_FILE_OK)
@@ skipping 21 matching lines @@
       start_changestamp,
       root_feed_changestamp,
       &changed_dirs);
 
   // Don't send directory content change notification while performing
   // the initial content retrieval.
   const bool should_notify_directory_changed = (start_changestamp != 0);
   if (should_notify_directory_changed) {
     for (std::set<FilePath>::iterator dir_iter = changed_dirs.begin();
         dir_iter != changed_dirs.end(); ++dir_iter) {
-      NotifyDirectoryChanged(*dir_iter);
+      FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(*dir_iter));
     }
   }
 
   return error;
 }
 
 
 // static
 void GDataFileSystem::RemoveStaleEntryOnUpload(const std::string& resource_id,
                                                GDataDirectory* parent_dir,
                                                GDataEntry* existing_entry) {
   if (existing_entry &&
       // This should always match, but just in case.
       existing_entry->parent() == parent_dir) {
     parent_dir->RemoveEntry(existing_entry);
   } else {
     LOG(ERROR) << "Entry for the existing file not found: " << resource_id;
   }
 }
 
-void GDataFileSystem::NotifyDirectoryChanged(const FilePath& directory_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  DVLOG(1) << "Content changed of " << directory_path.value();
-  // Notify the observers that content of |directory_path| has been changed.
-  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(directory_path));
-}
-
-void GDataFileSystem::NotifyDocumentFeedFetched(int num_accumulated_entries) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  DVLOG(1) << "Document feed fetched: " << num_accumulated_entries;
-  // Notify the observers that a document feed is fetched.
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnDocumentFeedFetched(num_accumulated_entries));
-}
-
 void GDataFileSystem::RunAndNotifyInitialLoadFinished(
     const FindEntryCallback& callback,
     GDataFileError error,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "Initial load finished";
   if (!callback.is_null())
     callback.Run(error, entry);
 
@@ skipping 25 matching lines @@
   if (!parent_dir)
     return GDATA_FILE_ERROR_FAILED;
 
   GDataEntry* new_entry = GDataEntry::FromDocumentEntry(
       parent_dir, doc_entry.get(), directory_service_.get());
   if (!new_entry)
     return GDATA_FILE_ERROR_FAILED;
 
   parent_dir->AddEntry(new_entry);
 
-  NotifyDirectoryChanged(directory_path);
+  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(directory_path));
   return GDATA_FILE_OK;
 }
 
 GDataFileSystem::FindMissingDirectoryResult
 GDataFileSystem::FindFirstMissingParentDirectory(
     const FilePath& directory_path,
     GURL* last_dir_content_url,
     FilePath* first_missing_parent_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 41 matching lines @@
 
   // If it's a file (only files have resource id), get its resource id so that
   // we can remove it after releasing the auto lock.
   if (entry->AsGDataFile())
     *resource_id = entry->AsGDataFile()->resource_id();
 
   GDataDirectory* parent_dir = entry->parent();
   if (!parent_dir->RemoveEntry(entry))
     return GDATA_FILE_ERROR_NOT_FOUND;
 
-  NotifyDirectoryChanged(parent_dir->GetFilePath());
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnDirectoryChanged(parent_dir->GetFilePath()));
   return GDATA_FILE_OK;
 }
 
 void GDataFileSystem::AddUploadedFile(
     UploadMode upload_mode,
     const FilePath& virtual_dir_path,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
     GDataCache::FileOperationType cache_operation,
     const base::Closure& callback) {
@@ skipping 56 matching lines @@
     directory_service_->GetEntryByResourceIdAsync(resource_id,
         base::Bind(&RemoveStaleEntryOnUpload, resource_id, parent_dir));
   }
 
   GDataFile* file = new_entry->AsGDataFile();
   DCHECK(file);
   const std::string& resource_id = file->resource_id();
   const std::string& md5 = file->file_md5();
   parent_dir->AddEntry(new_entry.release());
 
-  NotifyDirectoryChanged(virtual_dir_path);
+  FOR_EACH_OBSERVER(Observer, observers_,
+                    OnDirectoryChanged(virtual_dir_path));
 
   if (upload_mode == UPLOAD_NEW_FILE) {
     // Add the file to the cache if we have uploaded a new file.
     cache_->StoreOnUIThread(resource_id,
                             md5,
                             file_content_path,
                             cache_operation,
                             base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                        callback));
   } else if (upload_mode == UPLOAD_EXISTING_FILE) {
@@ skipping 27 matching lines @@
 void GDataFileSystem::SetHideHostedDocuments(bool hide) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (hide == hide_hosted_docs_)
     return;
 
   hide_hosted_docs_ = hide;
   const FilePath root_path = directory_service_->root()->GetFilePath();
 
   // Kick off directory refresh when this setting changes.
-  NotifyDirectoryChanged(root_path);
+  FOR_EACH_OBSERVER(Observer, observers_, OnDirectoryChanged(root_path));
 }
 
 //============= GDataFileSystem: internal helper functions =====================
 
 void GDataFileSystem::InitializePreferenceObserver() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pref_registrar_.reset(new PrefChangeRegistrar());
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
@@ skipping 418 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata