Changed api to notify when watched directory is deleted.

chrome/browser/chromeos/extensions/file_manager/event_router.cc

 // Copyright 2014 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/extensions/file_manager/event_router.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_change_registrar.h"
@@ skipping 368 matching lines @@
 
 EventRouter::DriveJobInfoWithStatus::DriveJobInfoWithStatus(
     const drive::JobInfo& info, const std::string& status)
     : job_info(info), status(status) {
 }
 
 EventRouter::EventRouter(Profile* profile)
     : pref_change_registrar_(new PrefChangeRegistrar),
       profile_(profile),
       device_event_router_(new DeviceEventRouterImpl(profile)),
-      weak_factory_(this) {
+      weak_factory_(this),
+      dispatch_directory_change_event_impl_(
+          base::Bind(&EventRouter::DispatchDirectoryChangeEventImpl,
+                     base::Unretained(this))) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ObserveEvents();
 }
 
 EventRouter::~EventRouter() {
 }
 
 void EventRouter::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 305 matching lines @@
                  file_manager_private::OnFileTransfersUpdated::kEventName,
                  file_manager_private::OnFileTransfersUpdated::Create(status));
 }
 
 void EventRouter::OnDirectoryChanged(const base::FilePath& drive_path) {
   HandleFileWatchNotification(NULL, drive_path, false);
 }
 
 void EventRouter::OnFileChanged(const drive::FileChange& changed_files) {
   typedef std::map<base::FilePath, drive::FileChange> FileChangeMap;
+  typedef drive::FileChange::ChangeList::List FileChangeList;
 
   FileChangeMap map;
   const drive::FileChange::Map& changed_file_map = changed_files.map();
   for (drive::FileChange::Map::const_iterator it = changed_file_map.begin();
        it != changed_file_map.end();
        it++) {
+    bool containsDirectoryDeletion = false;

[mtomasz, 2014/10/17 05:26:56]

nit: Please mark const what can be const.

[yawano, 2014/10/20 00:49:48]

Done.

+    FileChangeList list = it->second.list();
+    for (FileChangeList::const_iterator iter = list.begin();
+         iter != list.end();
+         ++iter) {
+      if (iter->IsDirectory() && iter->IsDelete()) {
+        containsDirectoryDeletion = true;
+        break;
+      }
+    }
+
     const base::FilePath& path = it->first;
     map[path.DirName()].Update(path, it->second);
+
+    // Since if the change is a deletion of a directory, it may have deleted a

[mtomasz, 2014/10/17 05:26:56]

Does this mean, that if we have directories /a and /a/b, both watched, and they
are removed on Drive, and /a is removed, then we were not getting a notification
for /a/b?

[mtomasz, 2014/10/17 05:26:56]

Since if -> Since (or) If

[yawano, 2014/10/20 00:49:48]

Yes. When we are watching /a and /a/b, and /a is deleted, the drive only
notifies /a is deleted. They don't notify that /a/b is also deleted.
On the other hand, if it's on Local, in the same situation we get two
notifications for /a and /a/b.

[yawano, 2014/10/20 00:49:48]

Done.

+    // watched directory, we need to notify it.
+    // e.g. When /a is deleted, it means /a/b is also deleted.
+    if (containsDirectoryDeletion) {
+      // Expaned the deleted directory path with watched paths.

[mtomasz, 2014/10/17 05:26:56]

typo: Expand

[yawano, 2014/10/20 00:49:48]

Done.

+      for (WatcherMap::const_iterator i = file_watchers_.lower_bound(path);
+        i != file_watchers_.end() &&
+        i->first.value().find(path.value()) == 0;
+        ++i) {
+        // Set an empty change list.
+        drive::FileChange::ChangeList change_list;
+        map[i->first].Update(i->first, change_list);
+      }
+    }
   }
 
   for (FileChangeMap::const_iterator it = map.begin(); it != map.end(); it++) {
     HandleFileWatchNotification(&(it->second), it->first, false);
   }
 }
 
 void EventRouter::OnDriveSyncError(drive::file_system::DriveSyncErrorType type,
                                    const base::FilePath& drive_path) {
   file_manager_private::DriveSyncErrorEvent event;
@@ skipping 51 matching lines @@
                                list,
                                got_error,
                                iter->second->GetExtensionIds());
 }
 
 void EventRouter::DispatchDirectoryChangeEvent(
     const base::FilePath& virtual_path,
     const drive::FileChange* list,
     bool got_error,
     const std::vector<std::string>& extension_ids) {
+  dispatch_directory_change_event_impl_.Run(virtual_path,
+                                            list, got_error, extension_ids);
+}
+
+void EventRouter::DispatchDirectoryChangeEventImpl(
+    const base::FilePath& virtual_path,
+    const drive::FileChange* list,
+    bool got_error,
+    const std::vector<std::string>& extension_ids) {
   if (!profile_) {
     NOTREACHED();
     return;
   }
   linked_ptr<drive::FileChange> changes;
   if (list)
     changes.reset(new drive::FileChange(*list));  // Copy
 
   for (size_t i = 0; i < extension_ids.size(); ++i) {
     std::string* extension_id = new std::string(extension_ids[i]);
@@ skipping 156 matching lines @@
 void EventRouter::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PROFILE_ADDED) {
     Profile* const added_profile = content::Source<Profile>(source).ptr();
     if (!added_profile->IsOffTheRecord())
       GrantAccessForAddedProfileToRunningInstance(added_profile, profile_);
   }
 }
 
+void EventRouter::SetDispatchDirectoryChangeEventImplForTesting(
+    const DispatchDirectoryChangeEventImplCallback& callback) {
+  dispatch_directory_change_event_impl_ = callback;
+}
+
 }  // namespace file_manager