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

chrome/browser/sync/engine/model_safe_worker.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_ENGINE_MODEL_SAFE_WORKER_H_
 #define CHROME_BROWSER_SYNC_ENGINE_MODEL_SAFE_WORKER_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback_old.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/sync/syncable/model_type.h"
+#include "chrome/browser/sync/sessions/unrecoverable_error_info.h"
 
 namespace base {
 class DictionaryValue;
 }  // namespace
 
 namespace browser_sync {
 
 enum ModelSafeGroup {
   GROUP_PASSIVE = 0,   // Models that are just "passively" being synced; e.g.
                        // changes to these models don't need to be pushed to a
@@ skipping 19 matching lines @@
 // cause an embedding application model to fall out of sync with the
 // syncable::Directory due to a race.
 class ModelSafeWorker : public base::RefCountedThreadSafe<ModelSafeWorker> {
  public:
   ModelSafeWorker();
   virtual ~ModelSafeWorker();
 
   // Any time the Syncer performs model modifications (e.g employing a
   // WriteTransaction), it should be done by this method to ensure it is done
   // from a model-safe thread.
-  virtual void DoWorkAndWaitUntilDone(Callback0::Type* work);
+  virtual void DoWorkAndWaitUntilDone(

[akalin, 2011/10/24 23:20:49]

It doesn't make sense to do the base class first and the derived class later
since you're changing the type signature.  That just means that all function
calls will go to this one and that'll break.

[lipalani1, 2011/10/25 02:29:46]

Done.

+    Callback1<sessions::UnrecoverableErrorInfo*>::Type* work,

[akalin, 2011/10/24 23:20:49]

the callbacktype should be ErrorInfo(void) (i.e., the work function should
return the struct directly)

[lipalani1, 2011/10/25 02:29:46]

As discussed we have to pass the pointer because it is in another thread..
On 2011/10/24 23:20:49, akalin wrote:

[akalin, 2011/10/25 03:20:06]

Actually, it's only CallDoWorkAndSignalTask (e.g.) that must take a pointer. 
The callback itself can return the struct directly.  To clarify, it'll look like
this:

PostTask(..., CallDoWorkAndSIgnalTask(done, event, &error_info));

....

void CallDoWorkAndSignalTask(Callback1 ... done, ..., ErrorInfo* error_info) {
  *error_info = done->Run();
  Signal();
}

To put it in another way, you don't want the fact that some subclasses of
ModelSafeWorker posts on other threads to leak into the ModelSafeWorker
interface.

+    sessions::UnrecoverableErrorInfo* error_info);

[akalin, 2011/10/24 23:20:49]

make this return the ErrorInfo class directly

[lipalani1, 2011/10/25 02:29:46]

Done.

 
   virtual ModelSafeGroup GetModelSafeGroup();
 
  private:
   friend class base::RefCountedThreadSafe<ModelSafeWorker>;
 
   DISALLOW_COPY_AND_ASSIGN(ModelSafeWorker);
 };
 
 // A map that details which ModelSafeGroup each syncable::ModelType
@@ skipping 36 matching lines @@
   virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) = 0;
  protected:
   virtual ~ModelSafeWorkerRegistrar() {}
  private:
   DISALLOW_COPY_AND_ASSIGN(ModelSafeWorkerRegistrar);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_MODEL_SAFE_WORKER_H_