Home | History | Annotate | Download | only in notifier 
      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 // A simple wrapper around invalidation::InvalidationClient that
      6 // handles all the startup/shutdown details and hookups.
      7 
      8 #ifndef CHROME_BROWSER_SYNC_NOTIFIER_CHROME_INVALIDATION_CLIENT_H_
      9 #define CHROME_BROWSER_SYNC_NOTIFIER_CHROME_INVALIDATION_CLIENT_H_
     10 #pragma once
     11 
     12 #include <map>
     13 #include <string>
     14 
     15 #include "base/basictypes.h"
     16 #include "base/compiler_specific.h"
     17 #include "base/memory/scoped_callback_factory.h"
     18 #include "base/memory/scoped_ptr.h"
     19 #include "base/memory/weak_ptr.h"
     20 #include "base/threading/non_thread_safe.h"
     21 #include "chrome/browser/sync/notifier/chrome_system_resources.h"
     22 #include "chrome/browser/sync/notifier/state_writer.h"
     23 #include "chrome/browser/sync/syncable/model_type.h"
     24 #include "chrome/browser/sync/syncable/model_type_payload_map.h"
     25 #include "google/cacheinvalidation/invalidation-client.h"
     26 
     27 // TODO(akalin): Move invalidation::InvalidationListener into its own
     28 // file and include that instead of invalidation-client.h (which
     29 // includes generated protobuf header files).
     30 
     31 namespace talk_base {
     32 class Task;
     33 }  // namespace
     34 
     35 namespace sync_notifier {
     36 
     37 class CacheInvalidationPacketHandler;
     38 class RegistrationManager;
     39 
     40 class ChromeInvalidationClient
     41     : public invalidation::InvalidationListener,
     42       public StateWriter {
     43  public:
     44   class Listener {
     45    public:
     46     virtual ~Listener();
     47 
     48     virtual void OnInvalidate(
     49         const syncable::ModelTypePayloadMap& type_payloads) = 0;
     50 
     51     virtual void OnSessionStatusChanged(bool has_session) = 0;
     52   };
     53 
     54   ChromeInvalidationClient();
     55 
     56   // Calls Stop().
     57   virtual ~ChromeInvalidationClient();
     58 
     59   // Does not take ownership of |listener| or |state_writer|.
     60   // |base_task| must still be non-NULL.
     61   void Start(
     62       const std::string& client_id, const std::string& client_info,
     63       const std::string& state, Listener* listener,
     64       StateWriter* state_writer, base::WeakPtr<talk_base::Task> base_task);
     65 
     66   void Stop();
     67 
     68   // Changes the task used to |base_task|, which must still be
     69   // non-NULL.  Must only be called between calls to Start() and
     70   // Stop().
     71   void ChangeBaseTask(base::WeakPtr<talk_base::Task> base_task);
     72 
     73   // Register the sync types that we're interested in getting
     74   // notifications for.  May be called at any time.
     75   void RegisterTypes(const syncable::ModelTypeSet& types);
     76 
     77   // invalidation::InvalidationListener implementation.
     78   virtual void Invalidate(const invalidation::Invalidation& invalidation,
     79                           invalidation::Closure* callback) OVERRIDE;
     80   virtual void InvalidateAll(invalidation::Closure* callback) OVERRIDE;
     81   virtual void RegistrationStateChanged(
     82       const invalidation::ObjectId& object_id,
     83       invalidation::RegistrationState new_state,
     84       const invalidation::UnknownHint& unknown_hint) OVERRIDE;
     85   virtual void AllRegistrationsLost(invalidation::Closure* callback) OVERRIDE;
     86   virtual void SessionStatusChanged(bool has_session) OVERRIDE;
     87 
     88   // StateWriter implementation.
     89   virtual void WriteState(const std::string& state) OVERRIDE;
     90 
     91  private:
     92   friend class ChromeInvalidationClientTest;
     93 
     94   // Should only be called between calls to Start() and Stop().
     95   void HandleOutboundPacket(
     96       invalidation::NetworkEndpoint* const& network_endpoint);
     97   void EmitInvalidation(
     98       const syncable::ModelTypeSet& types, const std::string& payload);
     99 
    100   base::NonThreadSafe non_thread_safe_;
    101   ChromeSystemResources chrome_system_resources_;
    102   base::ScopedCallbackFactory<ChromeInvalidationClient>
    103       scoped_callback_factory_;
    104   scoped_ptr<invalidation::NetworkCallback> handle_outbound_packet_callback_;
    105   Listener* listener_;
    106   StateWriter* state_writer_;
    107   scoped_ptr<invalidation::InvalidationClient> invalidation_client_;
    108   scoped_ptr<CacheInvalidationPacketHandler>
    109       cache_invalidation_packet_handler_;
    110   scoped_ptr<RegistrationManager> registration_manager_;
    111   std::map<syncable::ModelType, int64> max_invalidation_versions_;
    112   // Stored to pass to |registration_manager_| on start.
    113   syncable::ModelTypeSet registered_types_;
    114 
    115   DISALLOW_COPY_AND_ASSIGN(ChromeInvalidationClient);
    116 };
    117 
    118 }  // namespace sync_notifier
    119 
    120 #endif  // CHROME_BROWSER_SYNC_NOTIFIER_CHROME_INVALIDATION_CLIENT_H_
    121