Added merge session request throttle for XHR requests

chrome/browser/chromeos/login/merge_session_throttle.cc

 // Copyright (c) 2013 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/chromeos/login/merge_session_throttle.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
+#include "chrome/browser/chromeos/login/merge_session_load_page.h"
+#include "chrome/browser/chromeos/login/merge_session_xhr_request_waiter.h"
 #include "chrome/browser/chromeos/login/oauth2_login_manager.h"
 #include "chrome/browser/chromeos/login/oauth2_login_manager_factory.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_controller.h"
@@ skipping 10 matching lines @@
 using content::WebContents;
 
 namespace {
 
 const int64 kMaxSessionRestoreTimeInSec = 60;
 
 // The set of blocked profiles.
 class ProfileSet : public base::NonThreadSafe,
                    public std::set<Profile*> {
  public:
-  ProfileSet();
-  virtual ~ProfileSet();
+  ProfileSet() {
+  }
+
+  virtual ~ProfileSet() {
+  }
+
   static ProfileSet* Get();
 
  private:
   friend struct ::base::DefaultLazyInstanceTraits<ProfileSet>;
+
+  DISALLOW_COPY_AND_ASSIGN(ProfileSet);
 };
 
 // Set of all of profiles for which restore session is in progress.
 // This static member is accessible only form UI thread.
 static base::LazyInstance<ProfileSet> g_blocked_profiles =
     LAZY_INSTANCE_INITIALIZER;
 
-ProfileSet::ProfileSet() {
-}
-
-ProfileSet::~ProfileSet() {
-}
-
 ProfileSet* ProfileSet::Get() {
   return g_blocked_profiles.Pointer();
 }
 
 }  // namespace
 
 base::AtomicRefCount MergeSessionThrottle::all_profiles_restored_(0);
 
-MergeSessionThrottle::MergeSessionThrottle(net::URLRequest* request)
-    : request_(request) {
+MergeSessionThrottle::MergeSessionThrottle(net::URLRequest* request,
+                                           ResourceType::Type resource_type)
+    : request_(request),
+      resource_type_(resource_type) {
 }
 
 MergeSessionThrottle::~MergeSessionThrottle() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 void MergeSessionThrottle::WillStartRequest(bool* defer) {
-  DCHECK(request_->url().SchemeIsHTTPOrHTTPS());
-  if (!ShouldShowMergeSessionPage(request_->url()))
+  if (!ShouldDelayUrl(request_->url()))
     return;
 
   DVLOG(1) << "WillStartRequest: defer " << request_->url();
   const content::ResourceRequestInfo* info =
     content::ResourceRequestInfo::ForRequest(request_);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
-          &MergeSessionThrottle::ShowDeleayedLoadingPageOnUIThread,
+          &MergeSessionThrottle::DeleayResourceLoadingOnUIThread,
+          resource_type_,
           info->GetChildID(),
           info->GetRouteID(),
           request_->url(),
           base::Bind(
               &MergeSessionThrottle::OnBlockingPageComplete,
               AsWeakPtr())));
   *defer = true;
 }
 
 const char* MergeSessionThrottle::GetNameForLogging() const {
   return "MergeSessionThrottle";
 }
 
 // static.
 bool MergeSessionThrottle::AreAllSessionMergedAlready() {
   return !base::AtomicRefCountIsZero(&all_profiles_restored_);
 }
 
 void MergeSessionThrottle::OnBlockingPageComplete() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   controller()->Resume();
 }
 
-bool MergeSessionThrottle::ShouldShowMergeSessionPage(const GURL& url) const {
+bool MergeSessionThrottle::ShouldDelayUrl(const GURL& url) const {
   // If we are loading google properties while merge session is in progress,
   // we will show delayed loading page instead.
   return !net::NetworkChangeNotifier::IsOffline() &&
          !AreAllSessionMergedAlready() &&
          google_util::IsGoogleHostname(url.host(),
                                        google_util::ALLOW_SUBDOMAIN);
 }
 
 // static
 void MergeSessionThrottle::BlockProfile(Profile* profile) {
@@ skipping 20 matching lines @@
   ProfileSet::Get()->erase(profile);
 
   // Check if there is any other profile to block on.
   if (ProfileSet::Get()->size() == 0) {
     base::AtomicRefCountInc(&all_profiles_restored_);
     DVLOG(1) << "All profiles merged " << all_profiles_restored_;
   }
 }
 
 // static
-bool MergeSessionThrottle::ShouldShowInterstitialPage(
+bool MergeSessionThrottle::ShouldDelayRequest(
     int render_process_id,
     int render_view_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!chromeos::UserManager::Get()->IsUserLoggedIn()) {
     return false;
   } else if (!chromeos::UserManager::Get()->IsLoggedInAsRegularUser()) {
     // This is not a regular user session, let's remove the throttle
     // permanently.
     if (!AreAllSessionMergedAlready())
@@ skipping 62 matching lines @@
       UnblockProfile(profile);
       return false;
     }
   }
 
   NOTREACHED();
   return false;
 }
 
 // static.
-void MergeSessionThrottle::ShowDeleayedLoadingPageOnUIThread(
+void MergeSessionThrottle::DeleayResourceLoadingOnUIThread(
+    ResourceType::Type resource_type,
     int render_process_id,
     int render_view_id,
     const GURL& url,
-    const chromeos::MergeSessionLoadPage::CompletionCallback& callback) {
+    const CompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (ShouldShowInterstitialPage(render_process_id, render_view_id)) {
+  if (ShouldDelayRequest(render_process_id, render_view_id)) {
     // There is a chance that the tab closed after we decided to show
     // the offline page on the IO thread and before we actually show the
     // offline page here on the UI thread.
     RenderViewHost* render_view_host =
         RenderViewHost::FromID(render_process_id, render_view_id);
     WebContents* web_contents = render_view_host ?
         WebContents::FromRenderViewHost(render_view_host) : NULL;
-    if (web_contents)
+    if (resource_type == ResourceType::MAIN_FRAME) {
+      DVLOG(1) << "Creating page waiter for " << url.spec();
       (new chromeos::MergeSessionLoadPage(web_contents, url, callback))->Show();
+    } else {
+      DVLOG(1) << "Creating XHR waiter for " << url.spec();
+      DCHECK(resource_type == ResourceType::XHR);
+      Profile* profile = Profile::FromBrowserContext(
+          web_contents->GetBrowserContext());
+      (new chromeos::MergeSessionXHRRequestWaiter(profile,
+                                                  callback))->StartWaiting();
+    }
   } else {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, callback);
   }
 }
-