[Sync] Don't crash for encryption errors

sync/internal_api/base_node.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 "sync/internal_api/public/base_node.h"
 
 #include <stack>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "sync/internal_api/public/base_transaction.h"
 #include "sync/internal_api/syncapi_internal.h"
 #include "sync/protocol/app_specifics.pb.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/extension_specifics.pb.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/protocol/theme_specifics.pb.h"
 #include "sync/protocol/typed_url_specifics.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
+#include "sync/syncable/syncable_base_transaction.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/util/time.h"
 
 using sync_pb::AutofillProfileSpecifics;
 
 namespace syncer {
 
 using syncable::SPECIFICS;
 
 // Helper function to look up the int64 metahandle of an object given the ID
@@ skipping 15 matching lines @@
 bool BaseNode::DecryptIfNecessary() {
   if (!GetEntry()->GetUniqueServerTag().empty())
       return true;  // Ignore unique folders.
   const sync_pb::EntitySpecifics& specifics =
       GetEntry()->GetSpecifics();
   if (specifics.has_password()) {
     // Passwords have their own legacy encryption structure.
     scoped_ptr<sync_pb::PasswordSpecificsData> data(DecryptPasswordSpecifics(
         specifics, GetTransaction()->GetCryptographer()));
     if (!data) {
-      LOG(ERROR) << "Failed to decrypt password specifics.";
+      GetTransaction()->GetWrappedTrans()->OnUnrecoverableError(
+          FROM_HERE, std::string("Failed to decrypt encrypted node of type ") +
+                         ModelTypeToString(GetModelType()));
       return false;
     }
     password_data_.swap(data);
     return true;
   }
 
   // We assume any node with the encrypted field set has encrypted data and if
   // not we have no work to do, with the exception of bookmarks. For bookmarks
   // we must make sure the bookmarks data has the title field supplied. If not,
   // we fill the unencrypted_data_ with a copy of the bookmark specifics that
@@ skipping 12 matching lines @@
       unencrypted_data_.mutable_bookmark()->set_title(
           server_legal_title);
     }
     return true;
   }
 
   const sync_pb::EncryptedData& encrypted = specifics.encrypted();
   std::string plaintext_data = GetTransaction()->GetCryptographer()->
       DecryptToString(encrypted);
   if (plaintext_data.length() == 0) {
-    LOG(ERROR) << "Failed to decrypt encrypted node of type "
-               << ModelTypeToString(GetModelType()) << ".";
-    // Debugging for crbug.com/123223. We failed to decrypt the data, which
-    // means we applied an update without having the key or lost the key at a
-    // later point.
-    CHECK(false);
+    GetTransaction()->GetWrappedTrans()->OnUnrecoverableError(
+        FROM_HERE, std::string("Failed to decrypt encrypted node of type ") +
+                       ModelTypeToString(GetModelType()));
     return false;
   } else if (!unencrypted_data_.ParseFromString(plaintext_data)) {
-    // Debugging for crbug.com/123223. We should never succeed in decrypting
-    // but fail to parse into a protobuf.
-    CHECK(false);
+    GetTransaction()->GetWrappedTrans()->OnUnrecoverableError(
+        FROM_HERE, std::string("Failed to parse encrypted node of type ") +
+                       ModelTypeToString(GetModelType()));
     return false;
   }
   DVLOG(2) << "Decrypted specifics of type "
            << ModelTypeToString(GetModelType())
            << " with content: " << plaintext_data;
   return true;
 }
 
 const sync_pb::EntitySpecifics& BaseNode::GetUnencryptedSpecifics(
     const syncable::Entry* entry) const {
@@ skipping 193 matching lines @@
     const sync_pb::EntitySpecifics& specifics) {
   ModelType type = GetModelTypeFromSpecifics(specifics);
   DCHECK_NE(UNSPECIFIED, type);
   if (GetModelType() != UNSPECIFIED) {
     DCHECK_EQ(GetModelType(), type);
   }
   unencrypted_data_.CopyFrom(specifics);
 }
 
 }  // namespace syncer