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

chrome/browser/sync/syncable/syncable.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #pragma once
 
 #include <algorithm>
 #include <bitset>
@@ skipping 35 matching lines @@
 namespace sync_api {
 class ReadTransaction;
 class WriteNode;
 class ReadNode;
 }  // sync_api
 
 namespace syncable {
 class DirectoryChangeDelegate;
 class TransactionObserver;
 class Entry;
-
 std::ostream& operator<<(std::ostream& s, const Entry& e);
 
 class DirectoryBackingStore;
 
 static const int64 kInvalidMetaHandle = 0;
 
 // Things you need to update if you change any of the fields below:
 //  - EntryKernel struct in syncable.h (this file)
 //  - syncable_columns.h
 //  - syncable_enum_conversions{.h,.cc,_unittest.cc}
@@ skipping 800 matching lines @@
 
   // Unique to each account / client pair.
   std::string cache_guid() const;
 
   // These are backed by a thread-safe observer list, and so can be
   // called on any thread, and events will be sent to the observer on
   // the same thread that it was added on.
   void AddTransactionObserver(TransactionObserver* observer);
   void RemoveTransactionObserver(TransactionObserver* observer);
 
+  void set_unrecoverable_error();
+  bool unrecoverable_error() const;
+
  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);
   EntryKernel* GetRootEntry();
   bool ReindexId(EntryKernel* const entry, const Id& new_id);
   void ReindexParentId(EntryKernel* const entry, const Id& new_parent_id);
@@ skipping 258 matching lines @@
       const Id& parent_id);
 
   // Append the handles of the children of |parent_id| to |result|.
   void AppendChildHandles(
       const ScopedKernelLock& lock,
       const Id& parent_id, Directory::ChildHandles* result);
 
   Kernel* kernel_;
 
   DirectoryBackingStore* store_;
+
+  // Keep a copy to check before performing some shutdown operations.
+  // Otherwise if the store is corrupted and we perform those operations
+  // anyway(as part of sync shutdown) then we will crash there.
+  bool unrecoverable_error_;
 };
 
 class ScopedKernelLock {
  public:
   explicit ScopedKernelLock(const Directory*);
   ~ScopedKernelLock() {}
 
   base::AutoLock scoped_lock_;
   Directory* const dir_;
   DISALLOW_COPY_AND_ASSIGN(ScopedKernelLock);
 };
 
 // Transactions are now processed FIFO with a straight lock
 class BaseTransaction {
   friend class Entry;
  public:
   inline Directory* directory() const { return directory_; }
   inline Id root_id() const { return Id(); }
 
+  void set_unrecoverable_error();
+
   virtual ~BaseTransaction();
 
  protected:
   BaseTransaction(const tracked_objects::Location& from_here,
                   const char* name,
                   WriterTag writer,
                   Directory* directory);
 
   void Lock();
   void Unlock();
@@ skipping 63 matching lines @@
 bool IsLegalNewParent(BaseTransaction* trans, const Id& id, const Id& parentid);
 
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_