Retry: sync: Gracefully handle early shutdown

sync/internal_api/http_bridge_unittest.cc

 // Copyright 2012 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 "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_test_util.h"
+#include "sync/internal_api/public/base/cancelation_signal.h"
 #include "sync/internal_api/public/http_bridge.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 // TODO(timsteele): Should use PathService here. See Chromium Issue 3113.
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("chrome/test/data");
 }
@@ skipping 378 matching lines @@
   // Abort should have held a reference.
   io_waiter.Signal();
 
   // Done.
   sync_thread.Stop();
   io_thread()->Stop();
 }
 
 void HttpBridgeRunOnSyncThread(
     net::URLRequestContextGetter* baseline_context_getter,
+    CancelationSignal* factory_cancelation_signal,
     syncer::HttpPostProviderFactory** bridge_factory_out,
     syncer::HttpPostProviderInterface** bridge_out,
     base::WaitableEvent* signal_when_created,
     base::WaitableEvent* wait_for_shutdown) {
-  scoped_ptr<syncer::HttpPostProviderFactory> bridge_factory(
+  scoped_ptr<syncer::HttpBridgeFactory> bridge_factory(
       new syncer::HttpBridgeFactory(baseline_context_getter,
-                                    "test",
-                                    NetworkTimeUpdateCallback()));
+                                    NetworkTimeUpdateCallback(),
+                                    factory_cancelation_signal));
+  bridge_factory->Init("test");
   *bridge_factory_out = bridge_factory.get();
 
   HttpPostProviderInterface* bridge = bridge_factory->Create();
   *bridge_out = bridge;
 
   signal_when_created->Signal();
   wait_for_shutdown->Wait();
 
   bridge_factory->Destroy(bridge);
 }
@@ skipping 12 matching lines @@
 
   syncer::HttpPostProviderFactory* factory = NULL;
   syncer::HttpPostProviderInterface* bridge = NULL;
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
       new net::TestURLRequestContextGetter(io_thread()->message_loop_proxy()));
 
   base::WaitableEvent signal_when_created(false, false);
   base::WaitableEvent wait_for_shutdown(false, false);
 
+  CancelationSignal factory_cancelation_signal;
+
   // Create bridge factory and factory on sync thread and wait for the creation
   // to finish.
   sync_thread.message_loop()->PostTask(FROM_HERE,
       base::Bind(&HttpBridgeRunOnSyncThread,
                  base::Unretained(baseline_context_getter.get()),
-                 &factory, &bridge, &signal_when_created, &wait_for_shutdown));
+                 &factory_cancelation_signal ,&factory, &bridge,
+                 &signal_when_created, &wait_for_shutdown));
   signal_when_created.Wait();
 
   // Simulate sync shutdown by aborting bridge and shutting down factory on
   // frontend.
   bridge->Abort();
-  factory->Shutdown();
+  factory_cancelation_signal.RequestStop();
 
   // Wait for sync's RequestContextGetter to be cleared on IO thread and
   // check for reference count.
   base::WaitableEvent signal_wait_start(false, false);
   base::WaitableEvent wait_done(false, false);
   io_thread()->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&WaitOnIOThread, &signal_wait_start, &wait_done));
   signal_wait_start.Wait();
   // |baseline_context_getter| should have only one reference from local
   // variable.
   EXPECT_TRUE(baseline_context_getter->HasOneRef());
   baseline_context_getter = NULL;
 
   // Unblock and stop IO thread before sync thread.
   wait_done.Signal();
   io_thread()->Stop();
 
   // Unblock and stop sync thread.
   wait_for_shutdown.Signal();
   sync_thread.Stop();
 }
 
 }  // namespace syncer