Make GenericChangeProcessor upload attachments on startup.

sync/syncable/directory.cc

 // 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.
 
 #include "sync/syncable/directory.h"
 
+#include <algorithm>
 #include <iterator>
 
 #include "base/base64.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/internal_api/public/base/unique_position.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/syncable/entry.h"
@@ skipping 1039 matching lines @@
       std::copy(kernel_->unapplied_update_metahandles[type].begin(),
                 kernel_->unapplied_update_metahandles[type].end(),
                 back_inserter(*result));
     }
   }
 }
 
 void Directory::GetMetaHandlesOfType(BaseTransaction* trans,
                                      ModelType type,
                                      std::vector<int64>* result) {
+  ScopedKernelLock lock(this);
+  GetMetaHandlesOfType(lock, trans, type, result);
+}
+
+void Directory::GetMetaHandlesOfType(const ScopedKernelLock& lock,
+                                     BaseTransaction* trans,
+                                     ModelType type,
+                                     std::vector<int64>* result) {
   result->clear();
-  ScopedKernelLock lock(this);
   for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
        it != kernel_->metahandles_map.end(); ++it) {
     EntryKernel* entry = it->second;
     const ModelType entry_type =
         GetModelTypeFromSpecifics(entry->ref(SPECIFICS));
     if (entry_type == type)
       result->push_back(it->first);
   }
 }
 
@@ skipping 385 matching lines @@
     DCHECK_EQ(parent_id, (*i)->ref(PARENT_ID));
     result->push_back((*i)->ref(META_HANDLE));
   }
 }
 
 void Directory::UnmarkDirtyEntry(WriteTransaction* trans, Entry* entry) {
   CHECK(trans);
   entry->kernel_->clear_dirty(&kernel_->dirty_metahandles);
 }
 
+void Directory::GetAttachmentIdsToUpload(BaseTransaction* trans,
+                                         ModelType type,
+                                         AttachmentIdSet* id_set) {
+  // TODO(maniscalco): Maintain an index by ModelType and rewrite this method to
+  // use it.  The approach below is likely very expensive because it iterates
+  // all entries (bug 415199).
+  DCHECK(trans);
+  DCHECK(id_set);
+  id_set->clear();
+  AttachmentIdSet on_server_id_set;
+  AttachmentIdSet not_on_server_id_set;
+  std::vector<int64> metahandles;
+  {
+    ScopedKernelLock lock(this);
+    GetMetaHandlesOfType(lock, trans, type, &metahandles);
+    std::vector<int64>::const_iterator iter = metahandles.begin();
+    const std::vector<int64>::const_iterator end = metahandles.end();
+    // For all of this type's entries...
+    for (; iter != end; ++iter) {
+      EntryKernel* entry = GetEntryByHandle(*iter, &lock);
+      DCHECK(entry);
+      const sync_pb::AttachmentMetadata metadata =
+          entry->ref(ATTACHMENT_METADATA);
+      // for each of this entry's attachments...
+      for (int i = 0; i < metadata.record_size(); ++i) {
+        AttachmentId id =
+            AttachmentId::CreateFromProto(metadata.record(i).id());
+        // if this attachment is known to be on the server, remember it for
+        // later,
+        if (metadata.record(i).is_on_server()) {
+          on_server_id_set.insert(id);
+        } else {
+          // otherwise, add it to id_set.
+          not_on_server_id_set.insert(id);
+        }
+      }
+    }
+  }
+  // Why did we bother keeping a set of ids known to be on the server?  The
+  // is_on_server flag is stored denormalized so we can end up with two entries
+  // with the same attachment id where one says it's on the server and the other
+  // says it's not.  When this happens, we trust the one that says it's on the
+  // server.  To avoid re-uploading the same attachment mulitple times, we
+  // remove any ids known to be on the server from the id_set we are about to
+  // return.
+  //
+  // TODO(maniscalco): Eliminate redundant metadata storage (bug 415203).
+  std::set_difference(not_on_server_id_set.begin(),
+                      not_on_server_id_set.end(),
+                      on_server_id_set.begin(),
+                      on_server_id_set.end(),
+                      std::inserter(*id_set, id_set->end()));
+}
+
 }  // namespace syncable
 }  // namespace syncer