[Sync] Move 'sync' target to sync/

sync/engine/nigori_util.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/engine/nigori_util.h"
+#include "sync/engine/nigori_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
-#include "chrome/browser/sync/engine/syncer_util.h"
-#include "chrome/browser/sync/internal_api/write_node.h"
-#include "chrome/browser/sync/syncable/syncable.h"
-#include "chrome/browser/sync/util/cryptographer.h"
+#include "base/json/json_writer.h"
+#include "sync/engine/syncer_util.h"
+#include "sync/syncable/syncable.h"
+#include "sync/util/cryptographer.h"
 
 namespace syncable {
 
 bool ProcessUnsyncedChangesForEncryption(
     WriteTransaction* const trans,
     browser_sync::Cryptographer* cryptographer) {
   DCHECK(cryptographer->is_ready());
   // Get list of all datatypes with unsynced changes. It's possible that our
   // local changes need to be encrypted if encryption for that datatype was
   // just turned on (and vice versa).
   // Note: we do not attempt to re-encrypt data with a new key here as key
   // changes in this code path are likely due to consistency issues (we have
   // to be updated to a key we already have, e.g. an old key).
   std::vector<int64> handles;
   browser_sync::SyncerUtil::GetUnsyncedEntries(trans, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     MutableEntry entry(trans, GET_BY_HANDLE, handles[i]);
     const sync_pb::EntitySpecifics& specifics = entry.Get(SPECIFICS);
     // Ignore types that don't need encryption or entries that are already
     // encrypted.
     if (!SpecificsNeedsEncryption(cryptographer->GetEncryptedTypes(),
                                   specifics)) {
       continue;
     }
-    if (!sync_api::WriteNode::UpdateEntryWithEncryption(cryptographer,
-                                                        specifics,
-                                                        &entry)) {
+    if (!UpdateEntryWithEncryption(cryptographer, specifics, &entry)) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool VerifyUnsyncedChangesAreEncrypted(
     BaseTransaction* const trans,
     ModelTypeSet encrypted_types) {
@@ skipping 95 matching lines @@
         if (!cryptographer->CanDecryptUsingDefaultKey(specifics.encrypted()))
           return false;
       }
     }
     // Push the successor.
     to_visit.push(child.Get(NEXT_ID));
   }
   return true;
 }
 
+bool UpdateEntryWithEncryption(
+    browser_sync::Cryptographer* cryptographer,
+    const sync_pb::EntitySpecifics& new_specifics,
+    syncable::MutableEntry* entry) {
+  syncable::ModelType type = syncable::GetModelTypeFromSpecifics(new_specifics);
+  DCHECK_GE(type, syncable::FIRST_REAL_MODEL_TYPE);
+  const sync_pb::EntitySpecifics& old_specifics = entry->Get(SPECIFICS);
+  const syncable::ModelTypeSet encrypted_types =
+      cryptographer->GetEncryptedTypes();
+  // It's possible the nigori lost the set of encrypted types. If the current
+  // specifics are already encrypted, we want to ensure we continue encrypting.
+  bool was_encrypted = old_specifics.has_encrypted();
+  sync_pb::EntitySpecifics generated_specifics;
+  if (new_specifics.has_encrypted()) {
+    NOTREACHED() << "New specifics already has an encrypted blob.";
+    return false;
+  }
+  if ((!SpecificsNeedsEncryption(encrypted_types, new_specifics) &&
+       !was_encrypted) ||
+      !cryptographer->is_initialized()) {
+    // No encryption required or we are unable to encrypt.
+    generated_specifics.CopyFrom(new_specifics);
+  } else {
+    // Encrypt new_specifics into generated_specifics.
+    if (VLOG_IS_ON(2)) {
+      scoped_ptr<DictionaryValue> value(entry->ToValue());
+      std::string info;
+      base::JSONWriter::Write(value.get(), true, &info);
+      DVLOG(2) << "Encrypting specifics of type "
+               << syncable::ModelTypeToString(type)
+               << " with content: "
+               << info;
+    }
+    // Only copy over the old specifics if it is of the right type and already
+    // encrypted. The first time we encrypt a node we start from scratch, hence
+    // removing all the unencrypted data, but from then on we only want to
+    // update the node if the data changes or the encryption key changes.
+    if (syncable::GetModelTypeFromSpecifics(old_specifics) == type &&
+        was_encrypted) {
+      generated_specifics.CopyFrom(old_specifics);
+    } else {
+      syncable::AddDefaultFieldValue(type, &generated_specifics);
+    }
+    // Does not change anything if underlying encrypted blob was already up
+    // to date and encrypted with the default key.
+    if (!cryptographer->Encrypt(new_specifics,
+                                generated_specifics.mutable_encrypted())) {
+      NOTREACHED() << "Could not encrypt data for node of type "
+                   << syncable::ModelTypeToString(type);
+      return false;
+    }
+  }
+
+  // It's possible this entry was encrypted but didn't properly overwrite the
+  // non_unique_name (see crbug.com/96314).
+  bool encrypted_without_overwriting_name = (was_encrypted &&
+      entry->Get(syncable::NON_UNIQUE_NAME) != kEncryptedString);
+
+  // If we're encrypted but the name wasn't overwritten properly we still want
+  // to rewrite the entry, irrespective of whether the specifics match.
+  if (!encrypted_without_overwriting_name &&
+      old_specifics.SerializeAsString() ==
+          generated_specifics.SerializeAsString()) {
+    DVLOG(2) << "Specifics of type " << syncable::ModelTypeToString(type)
+             << " already match, dropping change.";
+    return true;
+  }
+
+  if (generated_specifics.has_encrypted()) {
+    // Overwrite the possibly sensitive non-specifics data.
+    entry->Put(syncable::NON_UNIQUE_NAME, kEncryptedString);
+    // For bookmarks we actually put bogus data into the unencrypted specifics,
+    // else the server will try to do it for us.
+    if (type == syncable::BOOKMARKS) {
+      sync_pb::BookmarkSpecifics* bookmark_specifics =
+          generated_specifics.mutable_bookmark();
+      if (!entry->Get(syncable::IS_DIR))
+        bookmark_specifics->set_url(kEncryptedString);
+      bookmark_specifics->set_title(kEncryptedString);
+    }
+  }
+  entry->Put(syncable::SPECIFICS, generated_specifics);
+  DVLOG(1) << "Overwriting specifics of type "
+           << syncable::ModelTypeToString(type)
+           << " and marking for syncing.";
+  syncable::MarkForSyncing(entry);
+  return true;
+}
+
 }  // namespace syncable