Add periodic check to see if context has been reset

rlz/lib/financial_ping.cc

 // Copyright (c) 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.
 //
 // Library functions related to the Financial Server ping.
 
 #include "rlz/lib/financial_ping.h"
 
+#include "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "rlz/lib/assert.h"
 #include "rlz/lib/lib_values.h"
 #include "rlz/lib/machine_id.h"
 #include "rlz/lib/rlz_lib.h"
 #include "rlz/lib/rlz_value_store.h"
 #include "rlz/lib/string_utils.h"
 
@@ skipping 56 matching lines @@
   double now_seconds = base::Time::Now().ToDoubleT();
   return static_cast<int64>(now_seconds * 1000 * 1000 * 10);
 #endif
 }
 
 }  // namespace
 
 
 namespace rlz_lib {
 
+using base::subtle::AtomicWord;
+
 bool FinancialPing::FormRequest(Product product,
     const AccessPoint* access_points, const char* product_signature,
     const char* product_brand, const char* product_id,
     const char* product_lang, bool exclude_machine_id,
     std::string* request) {
   if (!request) {
     ASSERT_STRING("FinancialPing::FormRequest: request is NULL");
     return false;
   }
 
@@ skipping 73 matching lines @@
     if (GetMachineId(&machine_id)) {
       base::StringAppendF(request, "&%s=%s", kMachineIdCgiVariable,
                           machine_id.c_str());
     }
   }
 
   return true;
 }
 
 #if defined(RLZ_NETWORK_IMPLEMENTATION_CHROME_NET)
-// The URLRequestContextGetter used by FinancialPing::PingServer().
-net::URLRequestContextGetter* g_context;
+// The pointer to URLRequestContextGetter used by FinancialPing::PingServer().
+// It is atomic pointer because it can be accessed and modified by multiple
+// threads.
+AtomicWord g_context;
 
 bool FinancialPing::SetURLRequestContext(
     net::URLRequestContextGetter* context) {
-  g_context = context;
+  base::subtle::NoBarrier_Store(
+      &g_context, reinterpret_cast<AtomicWord>(context));
   return true;
 }
 
 namespace {
 
 class FinancialPingUrlFetcherDelegate : public net::URLFetcherDelegate {
  public:
   FinancialPingUrlFetcherDelegate(const base::Closure& callback)
       : callback_(callback) {
   }
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
  private:
   base::Closure callback_;
 };
 
 void FinancialPingUrlFetcherDelegate::OnURLFetchComplete(
     const net::URLFetcher* source) {
   callback_.Run();
 }
 
+#if defined(RLZ_NETWORK_IMPLEMENTATION_CHROME_NET)
+bool send_financial_ping_interrupted_for_test = false;
+#endif
+
 }  // namespace
 
 #endif
 
+#if defined(RLZ_NETWORK_IMPLEMENTATION_CHROME_NET)
+void ShutdownCheck(base::WeakPtr<base::RunLoop> weak) {
+  if (!weak.get())
+    return;
+  if (!base::subtle::NoBarrier_Load(&g_context)) {
+    send_financial_ping_interrupted_for_test = true;
+    weak->QuitClosure().Run();
+    return;
+  }
+  // How frequently the financial ping thread should check
+  // the shutdown condition?
+  const base::TimeDelta kInterval = base::TimeDelta::FromMilliseconds(500);
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&ShutdownCheck, weak),
+      kInterval);
+}
+#endif
+
 bool FinancialPing::PingServer(const char* request, std::string* response) {
   if (!response)
     return false;
 
   response->clear();
 
 #if defined(RLZ_NETWORK_IMPLEMENTATION_WIN_INET)
   // Initialize WinInet.
   InternetHandle inet_handle = InternetOpenA(kFinancialPingUserAgent,
                                              INTERNET_OPEN_TYPE_PRECONFIG,
@@ skipping 37 matching lines @@
 
   DWORD bytes_read = 0;
   while (InternetReadFile(http_handle, buffer.get(), kMaxPingResponseLength,
                           &bytes_read) && bytes_read > 0) {
     response->append(buffer.get(), bytes_read);
     bytes_read = 0;
   };
 
   return true;
 #else
+  // Copy the pointer to stack because g_context may be set to NULL
+  // in different thread. The instance is guaranteed to exist while
+  // the method is running.
+  net::URLRequestContextGetter* context =
+      reinterpret_cast<net::URLRequestContextGetter*>(
+          base::subtle::NoBarrier_Load(&g_context));
+
   // Browser shutdown will cause the context to be reset to NULL.
-  if (!g_context)
+  if (!context)
     return false;
 
   // Run a blocking event loop to match the win inet implementation.
   scoped_ptr<base::MessageLoop> message_loop;
   // Ensure that we have a MessageLoop.
   if (!base::MessageLoop::current())
     message_loop.reset(new base::MessageLoop);
   base::RunLoop loop;
   FinancialPingUrlFetcherDelegate delegate(loop.QuitClosure());
 
   std::string url = base::StringPrintf("http://%s:%d%s",
                                        kFinancialServer, kFinancialPort,
                                        request);
 
   scoped_ptr<net::URLFetcher> fetcher(net::URLFetcher::Create(
       GURL(url), net::URLFetcher::GET, &delegate));
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE |
                         net::LOAD_DO_NOT_SEND_AUTH_DATA |
                         net::LOAD_DO_NOT_PROMPT_FOR_LOGIN |
                         net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES);
 
   // Ensure rlz_lib::SetURLRequestContext() has been called before sending
   // pings.
-  fetcher->SetRequestContext(g_context);
+  fetcher->SetRequestContext(context);
+
+  base::WeakPtrFactory<base::RunLoop> weak(&loop);
 
   const base::TimeDelta kTimeout = base::TimeDelta::FromMinutes(5);
   base::MessageLoop::ScopedNestableTaskAllower allow_nested(
       base::MessageLoop::current());
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
+      base::Bind(&ShutdownCheck, weak.GetWeakPtr()));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
       base::Bind(&net::URLFetcher::Start, base::Unretained(fetcher.get())));
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, loop.QuitClosure(), kTimeout);
 
   loop.Run();
 
   if (fetcher->GetResponseCode() != 200)
     return false;
 
   return fetcher->GetResponseAsString(response);
@@ skipping 40 matching lines @@
 
 
 bool FinancialPing::ClearLastPingTime(Product product) {
   ScopedRlzValueStoreLock lock;
   RlzValueStore* store = lock.GetStore();
   if (!store || !store->HasAccess(RlzValueStore::kWriteAccess))
     return false;
   return store->ClearPingTime(product);
 }
 
-}  // namespace
+#if defined(RLZ_NETWORK_IMPLEMENTATION_CHROME_NET)
+namespace test {
+
+void ResetSendFinancialPingInterrupted() {
+  send_financial_ping_interrupted_for_test = false;
+}
+
+bool WasSendFinancialPingInterrupted() {
+  return send_financial_ping_interrupted_for_test;
+}
+
+}  // namespace test
+#endif
+
+}  // namespace rlz_lib