Migrated sync_file_status, sync_action and sync_direction from fileapi:: namespace to sync_file_sys…

chrome/browser/sync_file_system/drive_file_sync_service.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/sync_file_system/drive_file_sync_service.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 134 matching lines @@
   std::string description_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskToken);
 };
 
 void DriveFileSyncService::OnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   SetPushNotificationEnabled(state);
 }
 
-void DriveFileSyncService::SetPushNotificationEnabled(

[tzik, 2013/02/19 09:09:01]

Could you rebase for this reordering?

[calvinlo, 2013/02/20 04:04:30]

Done.

-    syncer::InvalidatorState state) {
-  push_notification_enabled_ = (state == syncer::INVALIDATIONS_ENABLED);
-  if (!push_notification_enabled_)
-    return;
-
-  // Push notifications are enabled so reset polling timer.
-  UpdatePollingDelay(kPollingDelaySecondsWithNotification);
-}
-
 void DriveFileSyncService::OnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(push_notification_enabled_);
   DCHECK_EQ(1U, invalidation_map.size());
   const invalidation::ObjectId object_id(
       ipc::invalidation::ObjectSource::COSMO_CHANGELOG,
       kDriveInvalidationObjectId);
   DCHECK_EQ(1U, invalidation_map.count(object_id));
 
   may_have_unfetched_changes_ = true;
   MaybeStartFetchChanges();
 }
 
 struct DriveFileSyncService::ProcessRemoteChangeParam {
   scoped_ptr<TaskToken> token;
   RemoteChangeProcessor* processor;
   RemoteChange remote_change;
   fileapi::SyncFileCallback callback;
 
   DriveMetadata drive_metadata;
   bool metadata_updated;
   base::FilePath temporary_file_path;
   std::string md5_checksum;
-  fileapi::SyncAction sync_action;
+  SyncAction sync_action;
   bool clear_local_changes;
 
   ProcessRemoteChangeParam(scoped_ptr<TaskToken> token,
                            RemoteChangeProcessor* processor,
                            const RemoteChange& remote_change,
                            const fileapi::SyncFileCallback& callback)
       : token(token.Pass()),
         processor(processor),
         remote_change(remote_change),
         callback(callback),
         metadata_updated(false),
-        sync_action(fileapi::SYNC_ACTION_NONE),
+        sync_action(SYNC_ACTION_NONE),
         clear_local_changes(true) {
   }
 };
 
 DriveFileSyncService::ChangeQueueItem::ChangeQueueItem()
     : changestamp(0),
       sync_type(REMOTE_SYNC_TYPE_INCREMENTAL) {
 }
 
 DriveFileSyncService::ChangeQueueItem::ChangeQueueItem(
@@ skipping 401 matching lines @@
         metadata.set_md5_checksum(std::string());
       }
       metadata.set_conflicted(true);
       metadata.set_to_be_fetched(false);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url,
                      google_apis::HTTP_CONFLICT, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                       fileapi::SYNC_ACTION_NONE,
-                                       fileapi::SYNC_DIRECTION_NONE);
+                                       SYNC_FILE_STATUS_CONFLICTING,
+                                       SYNC_ACTION_NONE,
+                                       SYNC_DIRECTION_NONE);
       return;
     }
     case LOCAL_SYNC_OPERATION_RESOLVE_TO_REMOTE: {
       // Mark the file as to-be-fetched.
       DriveMetadata metadata;
       const fileapi::SyncStatusCode status =
           metadata_store_->ReadEntry(url, &metadata);
       DCHECK_EQ(fileapi::SYNC_STATUS_OK, status);
       metadata.set_conflicted(false);
       metadata.set_to_be_fetched(true);
@@ skipping 556 matching lines @@
     DriveMetadata metadata;
     metadata.set_resource_id(resource_id);
     metadata.set_md5_checksum(file_md5);
     metadata.set_conflicted(false);
     metadata.set_to_be_fetched(false);
     metadata_store_->UpdateEntry(
         url, metadata,
         base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                    AsWeakPtr(), base::Passed(&token), url, error, callback));
     NotifyObserversFileStatusChanged(url,
-                                     fileapi::SYNC_FILE_STATUS_SYNCED,
-                                     fileapi::SYNC_ACTION_ADDED,
-                                     fileapi::SYNC_DIRECTION_LOCAL_TO_REMOTE);
+                                     SYNC_FILE_STATUS_SYNCED,
+                                     SYNC_ACTION_ADDED,
+                                     SYNC_DIRECTION_LOCAL_TO_REMOTE);
     return;
   }
   FinalizeLocalSync(token.Pass(), callback,
                     GDataErrorCodeToSyncStatusCodeWrapper(error));
 }
 
 void DriveFileSyncService::DidUploadExistingFileForLocalSync(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
     const fileapi::SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id,
     const std::string& file_md5) {
   switch (error) {
     case google_apis::HTTP_SUCCESS: {
       DriveMetadata metadata;
       metadata.set_resource_id(resource_id);
       metadata.set_md5_checksum(file_md5);
       metadata.set_conflicted(false);
       metadata.set_to_be_fetched(false);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_SYNCED,
-                                       fileapi::SYNC_ACTION_UPDATED,
-                                       fileapi::SYNC_DIRECTION_LOCAL_TO_REMOTE);
+                                       SYNC_FILE_STATUS_SYNCED,
+                                       SYNC_ACTION_UPDATED,
+                                       SYNC_DIRECTION_LOCAL_TO_REMOTE);
       return;
     }
     case google_apis::HTTP_CONFLICT: {
       // Mark the file as conflicted.
       DriveMetadata metadata;
       const fileapi::SyncStatusCode status =
           metadata_store_->ReadEntry(url, &metadata);
       DCHECK_EQ(fileapi::SYNC_STATUS_OK, status);
       metadata.set_conflicted(true);
       metadata.set_to_be_fetched(false);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                       fileapi::SYNC_ACTION_NONE,
-                                       fileapi::SYNC_DIRECTION_NONE);
+                                       SYNC_FILE_STATUS_CONFLICTING,
+                                       SYNC_ACTION_NONE,
+                                       SYNC_DIRECTION_NONE);
       return;
     }
     case google_apis::HTTP_NOT_MODIFIED: {
       DidApplyLocalChange(token.Pass(), url, google_apis::HTTP_SUCCESS,
                           callback, fileapi::SYNC_STATUS_OK);
       return;
     }
     default: {
       const fileapi::SyncStatusCode status =
           GDataErrorCodeToSyncStatusCodeWrapper(error);
       DCHECK_NE(fileapi::SYNC_STATUS_OK, status);
       FinalizeLocalSync(token.Pass(), callback, status);
       return;
     }
   }
 }
 
 void DriveFileSyncService::DidDeleteFileForLocalSync(
     scoped_ptr<TaskToken> token,
     const fileapi::FileSystemURL& url,
     const fileapi::SyncStatusCallback& callback,
     google_apis::GDataErrorCode error) {
   switch (error) {
     case google_apis::HTTP_SUCCESS: {
       metadata_store_->DeleteEntry(
           url,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_SYNCED,
-                                       fileapi::SYNC_ACTION_DELETED,
-                                       fileapi::SYNC_DIRECTION_LOCAL_TO_REMOTE);
+                                       SYNC_FILE_STATUS_SYNCED,
+                                       SYNC_ACTION_DELETED,
+                                       SYNC_DIRECTION_LOCAL_TO_REMOTE);
       return;
     }
     case google_apis::HTTP_PRECONDITION:
       // FALLTHROUGH
     case google_apis::HTTP_CONFLICT: {
       // Mark the file as conflicted.
       DriveMetadata metadata;
       const fileapi::SyncStatusCode status =
           metadata_store_->ReadEntry(url, &metadata);
       DCHECK_EQ(fileapi::SYNC_STATUS_OK, status);
       metadata.set_conflicted(true);
       metadata.set_to_be_fetched(false);
       metadata_store_->UpdateEntry(
           url, metadata,
           base::Bind(&DriveFileSyncService::DidApplyLocalChange,
                      AsWeakPtr(), base::Passed(&token), url, error, callback));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                       fileapi::SYNC_ACTION_NONE,
-                                       fileapi::SYNC_DIRECTION_NONE);
+                                       SYNC_FILE_STATUS_CONFLICTING,
+                                       SYNC_ACTION_NONE,
+                                       SYNC_DIRECTION_NONE);
       return;
     }
     default: {
       const fileapi::SyncStatusCode status =
           GDataErrorCodeToSyncStatusCodeWrapper(error);
       DCHECK_NE(fileapi::SYNC_STATUS_OK, status);
       FinalizeLocalSync(token.Pass(), callback, status);
       return;
     }
   }
@@ skipping 37 matching lines @@
                  << (missing_local_file ? " (missing local file)" : " ")
                  << " remote_change: " << remote_file_change.DebugString()
                  << " ==> operation: ResolveConflictToRemoteChange";
 
         const fileapi::FileSystemURL& url = param->remote_change.url;
         param->drive_metadata.set_conflicted(false);
         param->drive_metadata.set_to_be_fetched(true);
         metadata_store_->UpdateEntry(
             url, drive_metadata, base::Bind(&EmptyStatusCallback));
 
-        param->sync_action = fileapi::SYNC_ACTION_ADDED;
+        param->sync_action = SYNC_ACTION_ADDED;
         DownloadForRemoteSync(param.Pass());
         return;
       }
 
       DCHECK(remote_file_change.IsDelete());
-      param->sync_action = fileapi::SYNC_ACTION_NONE;
+      param->sync_action = SYNC_ACTION_NONE;
       DeleteMetadataForRemoteSync(param.Pass());
       return;
     }
 
     DCHECK(!missing_local_file);
     if (remote_file_change.IsAddOrUpdate()) {
-      param->sync_action = fileapi::SYNC_ACTION_NONE;
+      param->sync_action = SYNC_ACTION_NONE;
       param->drive_metadata.set_conflicted(true);
       param->drive_metadata.set_to_be_fetched(false);
 
       metadata_store_->UpdateEntry(
           url, drive_metadata,
           base::Bind(&DriveFileSyncService::CompleteRemoteSync, AsWeakPtr(),
                      base::Passed(&param)));
       return;
     }
 
     DCHECK(remote_file_change.IsDelete());
     DVLOG(1) << "ProcessRemoteChange for " << url.DebugString()
              << (param->drive_metadata.conflicted() ? " (conflicted)" : " ")
              << (missing_local_file ? " (missing local file)" : " ")
              << " remote_change: " << remote_file_change.DebugString()
              << " ==> operation: ResolveConflictToLocalChange";
 
-    param->sync_action = fileapi::SYNC_ACTION_NONE;
+    param->sync_action = SYNC_ACTION_NONE;
     param->clear_local_changes = false;
 
     RemoteChangeProcessor* processor = param->processor;
     processor->RecordFakeLocalChange(
         url,
         fileapi::FileChange(fileapi::FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                             fileapi::SYNC_FILE_TYPE_FILE),
         base::Bind(&DriveFileSyncService::DidResolveConflictToLocalChange,
                    AsWeakPtr(), base::Passed(&param)));
     return;
   }
 
   DCHECK(!param->drive_metadata.conflicted());
   if (remote_file_change.IsAddOrUpdate()) {
     if (local_changes.empty()) {
       if (missing_local_file) {
-        param->sync_action = fileapi::SYNC_ACTION_ADDED;
+        param->sync_action = SYNC_ACTION_ADDED;
         DownloadForRemoteSync(param.Pass());
         return;
       }
 
       DCHECK(!missing_local_file);
-      param->sync_action = fileapi::SYNC_ACTION_UPDATED;
+      param->sync_action = SYNC_ACTION_UPDATED;
       DownloadForRemoteSync(param.Pass());
       return;
     }
 
     DCHECK(!local_changes.empty());
     if (local_changes.list().back().IsAddOrUpdate()) {
       param->drive_metadata.set_conflicted(true);
       param->drive_metadata.set_to_be_fetched(false);
 
       metadata_store_->UpdateEntry(
           url, drive_metadata,
           base::Bind(&DriveFileSyncService::CompleteRemoteSync, AsWeakPtr(),
                      base::Passed(&param)));
       NotifyObserversFileStatusChanged(url,
-                                       fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                       fileapi::SYNC_ACTION_NONE,
-                                       fileapi::SYNC_DIRECTION_NONE);
+                                       SYNC_FILE_STATUS_CONFLICTING,
+                                       SYNC_ACTION_NONE,
+                                       SYNC_DIRECTION_NONE);
       return;
     }
 
     DCHECK(local_changes.list().back().IsDelete());
-    param->sync_action = fileapi::SYNC_ACTION_ADDED;
+    param->sync_action = SYNC_ACTION_ADDED;
     DownloadForRemoteSync(param.Pass());
     return;
   }
 
   DCHECK(remote_file_change.IsDelete());
   if (local_changes.empty()) {
     if (missing_local_file) {
-      param->sync_action = fileapi::SYNC_ACTION_NONE;
+      param->sync_action = SYNC_ACTION_NONE;
       if (missing_db_entry)
         CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
       else
         DeleteMetadataForRemoteSync(param.Pass());
       return;
     }
     DCHECK(!missing_local_file);
-    param->sync_action = fileapi::SYNC_ACTION_DELETED;
+    param->sync_action = SYNC_ACTION_DELETED;
 
     const fileapi::FileChange& file_change = remote_file_change;
     param->processor->ApplyRemoteChange(
         file_change, base::FilePath(), url,
         base::Bind(&DriveFileSyncService::DidApplyRemoteChange, AsWeakPtr(),
                    base::Passed(&param)));
     return;
   }
 
   DCHECK(!local_changes.empty());
   if (local_changes.list().back().IsAddOrUpdate()) {
-    param->sync_action = fileapi::SYNC_ACTION_NONE;
+    param->sync_action = SYNC_ACTION_NONE;
     CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
     return;
   }
 
   DCHECK(local_changes.list().back().IsDelete());
-  param->sync_action = fileapi::SYNC_ACTION_NONE;
+  param->sync_action = SYNC_ACTION_NONE;
   if (missing_db_entry)
     CompleteRemoteSync(param.Pass(), fileapi::SYNC_STATUS_OK);
   else
     DeleteMetadataForRemoteSync(param.Pass());
 }
 
 void DriveFileSyncService::DidResolveConflictToLocalChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
     fileapi::SyncStatusCode status) {
   if (status != fileapi::SYNC_STATUS_OK) {
@@ skipping 43 matching lines @@
       temporary_file_path,
       base::Bind(&DriveFileSyncService::DidDownloadFileForRemoteSync,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DidDownloadFileForRemoteSync(
     scoped_ptr<ProcessRemoteChangeParam> param,
     google_apis::GDataErrorCode error,
     const std::string& md5_checksum) {
   if (error == google_apis::HTTP_NOT_MODIFIED) {
-    param->sync_action = fileapi::SYNC_ACTION_NONE;
+    param->sync_action = SYNC_ACTION_NONE;
     DidApplyRemoteChange(param.Pass(), fileapi::SYNC_STATUS_OK);
     return;
   }
 
   fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   if (status != fileapi::SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
@@ skipping 100 matching lines @@
                         AsWeakPtr(), base::Passed(&param), status));
     return;
   }
 
   if (!param->temporary_file_path.empty())
     DeleteTemporaryFile(param->temporary_file_path);
   NotifyTaskDone(status, param->token.Pass());
   if (status == fileapi::SYNC_STATUS_HAS_CONFLICT ||
       param->drive_metadata.conflicted()) {
     NotifyObserversFileStatusChanged(param->remote_change.url,
-                                     fileapi::SYNC_FILE_STATUS_CONFLICTING,
-                                     fileapi::SYNC_ACTION_NONE,
-                                     fileapi::SYNC_DIRECTION_NONE);
+                                     SYNC_FILE_STATUS_CONFLICTING,
+                                     SYNC_ACTION_NONE,
+                                     SYNC_DIRECTION_NONE);
   } else if (status == fileapi::SYNC_STATUS_OK &&
-             param->sync_action != fileapi::SYNC_ACTION_NONE) {
+             param->sync_action != SYNC_ACTION_NONE) {
     NotifyObserversFileStatusChanged(param->remote_change.url,
-                                     fileapi::SYNC_FILE_STATUS_SYNCED,
+                                     SYNC_FILE_STATUS_SYNCED,
                                      param->sync_action,
-                                     fileapi::SYNC_DIRECTION_REMOTE_TO_LOCAL);
+                                     SYNC_DIRECTION_REMOTE_TO_LOCAL);
   }
   param->callback.Run(status, param->remote_change.url);
 }
 
 bool DriveFileSyncService::AppendRemoteChange(
     const GURL& origin,
     const google_apis::ResourceEntry& entry,
     int64 changestamp,
     RemoteSyncType sync_type) {
   // TODO(tzik): Normalize the path here.
@@ skipping 126 matching lines @@
   if (found_url == origin_to_changes_map_.end())
     return false;
   const PathToChangeMap& path_to_change = found_url->second;
   PathToChangeMap::const_iterator found_path = path_to_change.find(url.path());
   if (found_path == path_to_change.end())
     return false;
   *change = found_path->second;
   return true;
 }
 
+fileapi::SyncStatusCode
+DriveFileSyncService::GDataErrorCodeToSyncStatusCodeWrapper(
+    google_apis::GDataErrorCode error) const {
+  fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
+  if (status != fileapi::SYNC_STATUS_OK && !sync_client_->IsAuthenticated())
+    return fileapi::SYNC_STATUS_AUTHENTICATION_FAILED;
+  return status;
+}
+
 void DriveFileSyncService::MaybeStartFetchChanges() {
   if (!token_ || GetCurrentState() == REMOTE_SERVICE_DISABLED) {
     // If another task is already running or the service is disabled
     // just return here.
     // Note that token_ should be already non-null if this is called
     // from NotifyTaskDone().
     return;
   }
 
   // If we have pending_batch_sync_origins, try starting the batch sync.
@@ skipping 103 matching lines @@
     if ((*itr)->href().GetOrigin() != resource_link.GetOrigin() ||
         (*itr)->href().path() != resource_link.path())
       continue;
 
     *origin_out = origin;
     return true;
   }
   return false;
 }
 
-// Register for Google Drive invalidation notifications through XMPP.
-void DriveFileSyncService::RegisterDriveNotifications() {
-  // Push notification registration might have already occurred if called from
-  // a different extension.
-  if (push_notification_registered_) {
-    return;
-  }
-
-  ProfileSyncService* profile_sync_service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  if (!profile_sync_service) {
-    return;
-  }
-
-  profile_sync_service->RegisterInvalidationHandler(this);
-  syncer::ObjectIdSet ids;
-  ids.insert(invalidation::ObjectId(
-      ipc::invalidation::ObjectSource::COSMO_CHANGELOG,
-      kDriveInvalidationObjectId));
-  profile_sync_service->UpdateRegisteredInvalidationIds(this, ids);
-  push_notification_registered_ = true;
-  SetPushNotificationEnabled(profile_sync_service->GetInvalidatorState());
-}
-
 void DriveFileSyncService::SchedulePolling() {
   if (polling_timer_.IsRunning() ||
       polling_delay_seconds_ < 0 ||
       GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
   DVLOG(1) << "Polling scheduled"
            << " (delay:" << polling_delay_seconds_ << "s)";
 
   polling_timer_.Start(
@@ skipping 28 matching lines @@
 
   int64 old_delay = polling_delay_seconds_;
 
   // Push notifications off.
   polling_delay_seconds_ = std::min(new_delay_sec, kMaximumPollingDelaySeconds);
 
   if (polling_delay_seconds_ < old_delay)
     polling_timer_.Stop();
 }
 
-fileapi::SyncStatusCode
-DriveFileSyncService::GDataErrorCodeToSyncStatusCodeWrapper(
-    google_apis::GDataErrorCode error) const {
-  fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
-  if (status != fileapi::SYNC_STATUS_OK && !sync_client_->IsAuthenticated())
-    return fileapi::SYNC_STATUS_AUTHENTICATION_FAILED;
-  return status;
+// Register for Google Drive invalidation notifications through XMPP.
+void DriveFileSyncService::RegisterDriveNotifications() {
+  // Push notification registration might have already occurred if called from
+  // a different extension.
+  if (push_notification_registered_) {
+    return;
+  }
+
+  ProfileSyncService* profile_sync_service =
+      ProfileSyncServiceFactory::GetForProfile(profile_);
+  if (!profile_sync_service) {
+    return;
+  }
+
+  profile_sync_service->RegisterInvalidationHandler(this);
+  syncer::ObjectIdSet ids;
+  ids.insert(invalidation::ObjectId(
+      ipc::invalidation::ObjectSource::COSMO_CHANGELOG,
+      kDriveInvalidationObjectId));
+  profile_sync_service->UpdateRegisteredInvalidationIds(this, ids);
+  push_notification_registered_ = true;
+  SetPushNotificationEnabled(profile_sync_service->GetInvalidatorState());
+}
+
+void DriveFileSyncService::SetPushNotificationEnabled(
+    syncer::InvalidatorState state) {
+  push_notification_enabled_ = (state == syncer::INVALIDATIONS_ENABLED);
+  if (!push_notification_enabled_)
+    return;
+
+  // Push notifications are enabled so reset polling timer.
+  UpdatePollingDelay(kPollingDelaySecondsWithNotification);
 }
 
 void DriveFileSyncService::NotifyObserversFileStatusChanged(
     const fileapi::FileSystemURL& url,
-    fileapi::SyncFileStatus sync_status,
-    fileapi::SyncAction action_taken,
-    fileapi::SyncDirection direction) {
-  if (sync_status != fileapi::SYNC_FILE_STATUS_SYNCED) {
-    DCHECK_EQ(fileapi::SYNC_ACTION_NONE, action_taken);
-    DCHECK_EQ(fileapi::SYNC_DIRECTION_NONE, direction);
+    SyncFileStatus sync_status,
+    SyncAction action_taken,
+    SyncDirection direction) {
+  if (sync_status != SYNC_FILE_STATUS_SYNCED) {
+    DCHECK_EQ(SYNC_ACTION_NONE, action_taken);
+    DCHECK_EQ(SYNC_DIRECTION_NONE, direction);
   }
 
   FOR_EACH_OBSERVER(
       FileStatusObserver, file_status_observers_,
       OnFileStatusChanged(url, sync_status, action_taken, direction));
 }
 
 }  // namespace sync_file_system