Make GenericChangeProcessor upload attachments on startup.

sync/syncable/directory.h

 // Copyright 2013 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.
 
 #ifndef SYNC_SYNCABLE_DIRECTORY_H_
 #define SYNC_SYNCABLE_DIRECTORY_H_
 
 #include <deque>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_util.h"
 #include "base/gtest_prod_util.h"
 #include "base/values.h"
+#include "sync/api/attachments/attachment_id.h"
 #include "sync/base/sync_export.h"
 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/syncable/dir_open_result.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/metahandle_set.h"
 #include "sync/syncable/parent_child_index.h"
 #include "sync/syncable/syncable_delete_journal.h"
 
@@ skipping 378 matching lines @@
   void GetMetahandlesByAttachmentId(
       BaseTransaction* trans,
       const sync_pb::AttachmentIdProto& attachment_id_proto,
       Metahandles* result);
 
   // Change entry to not dirty. Used in special case when we don't want to
   // persist modified entry on disk. e.g. SyncBackupManager uses this to
   // preserve sync preferences in DB on disk.
   void UnmarkDirtyEntry(WriteTransaction* trans, Entry* entry);
 
+  // Clears |id_set| and fills it with the ids of attachments that need to be
+  // uploaded to the sync server.
+  void GetAttachmentIdsToUpload(BaseTransaction* trans,
+                                ModelType type,
+                                AttachmentIdSet* id_set);
+
  protected:  // for friends, mainly used by Entry constructors
   virtual EntryKernel* GetEntryByHandle(int64 handle);
   virtual EntryKernel* GetEntryByHandle(int64 metahandle,
       ScopedKernelLock* lock);
   virtual EntryKernel* GetEntryById(const Id& id);
   EntryKernel* GetEntryByServerTag(const std::string& tag);
   virtual EntryKernel* GetEntryByClientTag(const std::string& tag);
   bool ReindexId(BaseWriteTransaction* trans, EntryKernel* const entry,
                  const Id& new_id);
   bool ReindexParentId(BaseWriteTransaction* trans, EntryKernel* const entry,
@@ skipping 170 matching lines @@
   void RemoveFromAttachmentIndex(
       const int64 metahandle,
       const sync_pb::AttachmentMetadata& attachment_metadata,
       const ScopedKernelLock& lock);
   // Add each of |metahandle|'s attachment ids to the index_by_attachment_id.
   void AddToAttachmentIndex(
       const int64 metahandle,
       const sync_pb::AttachmentMetadata& attachment_metadata,
       const ScopedKernelLock& lock);
 
+  // A private version of the public GetMetaHandlesOfType for when you already
+  // have a ScopedKernelLock.
+  void GetMetaHandlesOfType(const ScopedKernelLock& lock,
+                            BaseTransaction* trans,
+                            ModelType type,
+                            std::vector<int64>* result);
+
   Kernel* kernel_;
 
   scoped_ptr<DirectoryBackingStore> store_;
 
   UnrecoverableErrorHandler* const unrecoverable_error_handler_;
   const ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
   bool unrecoverable_error_set_;
 
   // Not owned.
   NigoriHandler* const nigori_handler_;
   Cryptographer* const cryptographer_;
 
   InvariantCheckLevel invariant_check_level_;
 
   // Maintain deleted entries not in |kernel_| until it's verified that they
   // are deleted in native models as well.
   scoped_ptr<DeleteJournal> delete_journal_;
 
   DISALLOW_COPY_AND_ASSIGN(Directory);
 };
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif // SYNC_SYNCABLE_DIRECTORY_H_