Introduce the plumbing necessary to report Unrecoverable error from model safe workers.

chrome/browser/sync/syncable/syncable.cc

 // Copyright (c) 2011 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/syncable/syncable.h"
 
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <iomanip>
@@ skipping 23 matching lines @@
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/syncable_changes_version.h"
 #include "chrome/browser/sync/syncable/syncable_columns.h"
 #include "chrome/browser/sync/syncable/syncable_enum_conversions.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/transaction_observer.h"
 #include "chrome/browser/sync/util/logging.h"
 #include "net/base/escape.h"
 
 namespace {
+
 enum InvariantCheckLevel {
   OFF = 0,
   VERIFY_IN_MEMORY = 1,
   FULL_DB_VERIFICATION = 2
 };
 
 static const InvariantCheckLevel kInvariantCheckLevel = VERIFY_IN_MEMORY;
 
 // Max number of milliseconds to spend checking syncable entry invariants
 static const int kInvariantCheckMaxMs = 50;
-}  // namespace
+
+}  // namespace.
 
 using std::string;
 
 namespace syncable {
 
 #define ENUM_CASE(x) case x: return #x; break
 
 std::string WriterTagToString(WriterTag writer_tag) {
   switch (writer_tag) {
     ENUM_CASE(INVALID);
@@ skipping 353 matching lines @@
   delete unapplied_update_metahandles;
   delete dirty_metahandles;
   delete metahandles_to_purge;
   delete parent_id_child_index;
   delete client_tag_index;
   delete ids_index;
   STLDeleteElements(metahandles_index);
   delete metahandles_index;
 }
 
-Directory::Directory() : kernel_(NULL), store_(NULL) {
+Directory::Directory() : kernel_(NULL), store_(NULL),
+                        unrecoverable_error_(false) {
 }
 
 Directory::~Directory() {
   Close();
 }
 
 DirOpenResult Directory::Open(const FilePath& file_path, const string& name,
                               DirectoryChangeDelegate* delegate) {
   const DirOpenResult result = OpenImpl(file_path, name, delegate);
   if (OPENED != result)
@@ skipping 250 matching lines @@
   // greater magnitude than could possibly be reached before the next save
   // changes.  In other words, it's effectively impossible for the user to
   // generate 65536 new bookmarks in 3 seconds.
   snapshot->kernel_info.next_id -= 65536;
   snapshot->kernel_info_status = kernel_->info_status;
   // This one we reset on failure.
   kernel_->info_status = KERNEL_SHARE_INFO_VALID;
 }
 
 bool Directory::SaveChanges() {
+  if (unrecoverable_error_)
+    return true;
   bool success = false;
   DCHECK(store_);
 
   base::AutoLock scoped_lock(kernel_->save_changes_mutex);
 
   // Snapshot and save.
   SaveChangesSnapshot snapshot;
   TakeSnapshotForSaveChanges(&snapshot);
   success = store_->SaveChanges(snapshot);
 
@@ skipping 401 matching lines @@
 }
 
 void Directory::AddTransactionObserver(TransactionObserver* observer) {
   kernel_->observers->AddObserver(observer);
 }
 
 void Directory::RemoveTransactionObserver(TransactionObserver* observer) {
   kernel_->observers->RemoveObserver(observer);
 }
 
+void Directory::set_unrecoverable_error() {
+  unrecoverable_error_ = true;
+}
+
+bool Directory::unrecoverable_error() const {
+  return unrecoverable_error_;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ScopedKernelLock
 
 ScopedKernelLock::ScopedKernelLock(const Directory* dir)
   :  scoped_lock_(dir->kernel_->mutex), dir_(const_cast<Directory*>(dir)) {
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Transactions
 
@@ skipping 20 matching lines @@
 BaseTransaction::BaseTransaction(const tracked_objects::Location& from_here,
                                  const char* name,
                                  WriterTag writer,
                                  Directory* directory)
     : from_here_(from_here), name_(name), writer_(writer),
       directory_(directory), dirkernel_(directory->kernel_) {
   dirkernel_->observers->Notify(
       &TransactionObserver::OnTransactionStart, from_here_, writer_);
 }
 
+void BaseTransaction::set_unrecoverable_error() {
+  directory_->set_unrecoverable_error();
+}
+
 BaseTransaction::~BaseTransaction() {
   dirkernel_->observers->Notify(
       &TransactionObserver::OnTransactionEnd, from_here_, writer_);
 }
 
 ReadTransaction::ReadTransaction(const tracked_objects::Location& location,
                                  Directory* directory)
     : BaseTransaction(location, "Read", INVALID, directory) {
   Lock();
 }
@@ skipping 105 matching lines @@
 
 void WriteTransaction::NotifyTransactionComplete(
     ModelTypeBitSet models_with_changes) {
   dirkernel_->delegate->HandleTransactionCompleteChangeEvent(
       models_with_changes);
 }
 
 WriteTransaction::~WriteTransaction() {
   const ImmutableEntryKernelMutationMap& mutations = RecordMutations();
 
+  if (directory_->unrecoverable_error())
+    return;
   if (OFF != kInvariantCheckLevel) {
     const bool full_scan = (FULL_DB_VERIFICATION == kInvariantCheckLevel);
     if (full_scan)
       directory()->CheckTreeInvariants(this, full_scan);
     else
       directory()->CheckTreeInvariants(this, mutations.Get());
   }
 
   UnlockAndNotify(mutations);
 }
@@ skipping 183 matching lines @@
     ScopedIndexUpdater<ParentIdAndHandleIndexer> updater(lock, kernel_,
         dir()->kernel_->parent_id_child_index);
 
     kernel_->put(IS_DEL, is_del);
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
 
   if (!is_del)
     // Restores position to the 0th index.
     if (!PutPredecessor(Id())) {
-      // TODO(lipalani) : Propagate the error to caller. crbug.com/100444.
-      NOTREACHED();
+      return false;
     }
 
   return true;
 }
 
 bool MutableEntry::Put(Int64Field field, const int64& value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
     ScopedKernelLock lock(dir());
     if (SERVER_POSITION_IN_PARENT == field) {
@@ skipping 478 matching lines @@
   CHECK(result);
   for (iterator i = GetParentChildIndexLowerBound(lock, parent_id),
            end = GetParentChildIndexUpperBound(lock, parent_id);
        i != end; ++i) {
     DCHECK_EQ(parent_id, (*i)->ref(PARENT_ID));
     result->push_back((*i)->ref(META_HANDLE));
   }
 }
 
 }  // namespace syncable