[Sync] Trigger refresh for synced notifications on context change

chrome/browser/extensions/api/synced_notifications_private/synced_notifications_shim_unittest.cc

 // Copyright 2014 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/extensions/api/synced_notifications_private/synced_notifications_shim.h"
 
 #include "base/json/json_writer.h"
 #include "extensions/browser/event_router.h"
 #include "sync/api/fake_sync_change_processor.h"
 #include "sync/api/sync_change.h"
@@ skipping 63 matching lines @@
   virtual ~SyncedNotificationsShimTest();
 
   // Starts sync for both sync types.
   void StartSync();
   // Starts sync for the specified datatype |type|.
   void StartSync(syncer::ModelType type);
 
   // Transfers ownership of the last event received.
   scoped_ptr<Event> GetLastEvent();
 
+  // Records that a refresh has been requested.
+  void RequestRefresh();
+
   SyncedNotificationsShim* shim() { return &shim_; }
   syncer::FakeSyncChangeProcessor* notification_processor() {
     return notification_processor_;
   }
   syncer::FakeSyncChangeProcessor* app_info_processor() {
     return app_info_processor_;
   }
+  bool refresh_requested() const { return refresh_requested_; }
 
  private:
   void EventCallback(scoped_ptr<Event> event);
 
   // Shim being tested.
   SyncedNotificationsShim shim_;
 
   syncer::FakeSyncChangeProcessor* notification_processor_;
   syncer::FakeSyncChangeProcessor* app_info_processor_;
 
   // The last event fired by the shim.
   scoped_ptr<Event> last_event_fired_;
+
+  // Whether a refresh has been requested;
+  bool refresh_requested_;
 };
 
 SyncedNotificationsShimTest::SyncedNotificationsShimTest()
     : shim_(base::Bind(&SyncedNotificationsShimTest::EventCallback,
+                       base::Unretained(this)),
+            base::Bind(&SyncedNotificationsShimTest::RequestRefresh,
                        base::Unretained(this))),
       notification_processor_(NULL),
-      app_info_processor_(NULL) {}
+      app_info_processor_(NULL),
+      refresh_requested_(false) {}
 
 SyncedNotificationsShimTest::~SyncedNotificationsShimTest() {}
 
 void SyncedNotificationsShimTest::EventCallback(scoped_ptr<Event> event) {
   ASSERT_FALSE(last_event_fired_);
   last_event_fired_ = event.Pass();
 }
 
+void SyncedNotificationsShimTest::RequestRefresh() {
+  ASSERT_FALSE(refresh_requested_);
+  refresh_requested_ = true;
+}
+
 scoped_ptr<Event> SyncedNotificationsShimTest::GetLastEvent() {
   return last_event_fired_.Pass();
 }
 
 void SyncedNotificationsShimTest::StartSync() {
   StartSync(syncer::SYNCED_NOTIFICATIONS);
   StartSync(syncer::SYNCED_NOTIFICATION_APP_INFO);
   GetLastEvent();
 }
 
@@ skipping 185 matching lines @@
                 .GetSpecifics()
                 .synced_notification()
                 .SerializeAsString());
 }
 
 // Verify that SetRenderContext updates the datatype context properly.
 TEST_F(SyncedNotificationsShimTest, SetRenderContext) {
   const std::string kContext = "context";
   EXPECT_FALSE(shim()->SetRenderContext(
       synced_notifications_private::REFRESH_REQUEST_REFRESH_NEEDED, kContext));
+  EXPECT_FALSE(refresh_requested());
 
   StartSync();
 
   EXPECT_TRUE(shim()->SetRenderContext(
       synced_notifications_private::REFRESH_REQUEST_REFRESH_NEEDED, kContext));
   EXPECT_EQ(kContext, notification_processor()->context());
+  EXPECT_TRUE(refresh_requested());
 }
 
 }  // namespace