OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #ifndef CHROME_BROWSER_SYNC_GLUE_SHARED_CHANGE_PROCESSOR_H_ |
| 6 #define CHROME_BROWSER_SYNC_GLUE_SHARED_CHANGE_PROCESSOR_H_ |
| 7 #pragma once |
| 8 |
| 9 #include "base/memory/ref_counted.h" |
| 10 #include "base/synchronization/lock.h" |
| 11 #include "chrome/browser/sync/glue/generic_change_processor.h" |
| 12 #include "content/browser/browser_thread.h" |
| 13 |
| 14 class SyncData; |
| 15 class SyncableService; |
| 16 |
| 17 typedef std::vector<SyncData> SyncDataList; |
| 18 |
| 19 namespace browser_sync { |
| 20 |
| 21 |
| 22 // A ref-counted GenericChangeProcessor for use with datatypes that don't live |
| 23 // on the UI thread. We need to make it refcounted as the ownership transfer |
| 24 // from the DataTypeController is dependent on threading, and hence racy. |
| 25 // The SharedChangeProcessor should be created and destroyed on the UI thread, |
| 26 // but should only be connected and used on the same thread as the datatype it |
| 27 // interacts with. The only thread-safe method is Disconnect, which will |
| 28 // disconnect the change processor from the syncer, letting us shut down the |
| 29 // syncer/datatype without waiting for non-UI threads. |
| 30 class SharedChangeProcessor |
| 31 : public GenericChangeProcessor, |
| 32 public base::RefCountedThreadSafe<SharedChangeProcessor, |
| 33 BrowserThread::DeleteOnUIThread> { |
| 34 public: |
| 35 // Create an uninitialized change processor (to be later connected). |
| 36 explicit SharedChangeProcessor(UnrecoverableErrorHandler* error_handler); |
| 37 |
| 38 // Connect to the syncer and the SyncableService specified. Should be called |
| 39 // on the same thread the datatype resides. |
| 40 virtual void Connect(SyncableService* local_service, |
| 41 sync_api::UserShare* user_share); |
| 42 |
| 43 // Disconnects from the syncer. May be called from any thread. After this, all |
| 44 // attempts to interact with the change processor by |local_service_| are |
| 45 // dropped and return errors. The syncer will be safe to shut down from the |
| 46 // point of view of this datatype. |
| 47 // Note: Once disconnected, you cannot reconnect without creating a new |
| 48 // change processor. |
| 49 virtual void Disconnect(); |
| 50 |
| 51 // GenericChangeProcessor implementation (with disconnect support). |
| 52 // Should only be called on the same thread the datatype resides. |
| 53 virtual SyncError ProcessSyncChanges( |
| 54 const tracked_objects::Location& from_here, |
| 55 const SyncChangeList& change_list) OVERRIDE; |
| 56 virtual SyncError GetSyncDataForType(syncable::ModelType type, |
| 57 SyncDataList* current_sync_data); |
| 58 virtual bool SyncModelHasUserCreatedNodes(syncable::ModelType type, |
| 59 bool* has_nodes); |
| 60 virtual bool CryptoReadyIfNecessary(syncable::ModelType type); |
| 61 |
| 62 protected: |
| 63 friend class base::RefCountedThreadSafe<SharedChangeProcessor>; |
| 64 friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>; |
| 65 friend class DeleteTask<SharedChangeProcessor>; |
| 66 |
| 67 virtual ~SharedChangeProcessor() OVERRIDE; |
| 68 |
| 69 private: |
| 70 // Monitor lock for this object. All methods that interact with the Syncer |
| 71 // must aquire this lock and check whether we're disconnected or not. Once |
| 72 // disconnected, all attempted changes to or loads from the syncer return |
| 73 // errors. This enables us to shut down the syncer without having to wait |
| 74 // for possibly non-UI thread datatypes to complete work. |
| 75 base::Lock monitor_lock_; |
| 76 bool disconnected_; |
| 77 |
| 78 DISALLOW_COPY_AND_ASSIGN(SharedChangeProcessor); |
| 79 }; |
| 80 |
| 81 } // namespace browser_sync |
| 82 |
| 83 #endif // CHROME_BROWSER_SYNC_GLUE_SHARED_CHANGE_PROCESSOR_H_ |
OLD | NEW |