Resolve new GAIA flow's infinite loop.

chrome/browser/chromeos/profiles/profile_helper.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/profiles/profile_helper.h"
 
+#include "base/barrier_closure.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
+#include "content/public/browser/web_contents.h"
+#include "extensions/browser/guest_view/guest_view_manager.h"
+#include "extensions/browser/guest_view/web_view/web_view_guest.h"
 
 namespace chromeos {
 
 namespace {
 
 // As defined in /chromeos/dbus/cryptohome_client.cc.
 static const char kUserIdHashSuffix[] = "-hash";
 
 bool ShouldAddProfileDirPrefix(const std::string& user_id_hash) {
   // Do not add profile dir prefix for legacy profile dir and test
@@ skipping 10 matching lines @@
  public:
   explicit UsernameHashMatcher(const std::string& h) : username_hash(h) {}
   bool operator()(const user_manager::User* user) const {
     return user->username_hash() == username_hash;
   }
 
  private:
   const std::string& username_hash;
 };
 
+bool GetWebViewPartition(std::set<content::StoragePartition*>* partition_set,
+                         content::WebContents* web_contents) {
+  extensions::WebViewGuest* view_guest =
+      extensions::WebViewGuest::FromWebContents(web_contents);
+  if (view_guest) {
+    content::StoragePartition* partition =
+        content::BrowserContext::GetStoragePartition(
+            web_contents->GetBrowserContext(), web_contents->GetSiteInstance());
+    partition_set->insert(partition);
+  }
+  return false;
+}
+
+void ClearContentsData(content::WebContents* web_contents,
+                       const base::Closure& on_clear_callback) {
+  content::BrowserContext* context = web_contents->GetBrowserContext();
+  extensions::GuestViewManager* manager =
+      extensions::GuestViewManager::FromBrowserContext(context);
+  std::set<content::StoragePartition*> partition_set;
+  manager->ForEachGuest(web_contents,

[xiyuan, 2015/03/20 17:36:21]

Since we are interested in storage partitions, we probably can use
BrowserContext::ForEachStoragePartition. So we just clear everything in signin
profile. And there would be no need to pass in the owner webcontents.

[Ivan Podogov, 2015/03/21 14:47:43]

Interesting thing to note here is that we have two partitions active at this
moment: profile's default one, and the webview storage. ForEachStoragePartition
enumerates both (which is not surprising), and this code here enumerates only
the second one (which is also quite logical). Thing to note here is that the
default partition will actually be cleared in ClearSigninProfile anyway by the
BrowsingDataRemover.
In the future we may want to use ForEachStoragePartition inside the
BrowsingDataRemover (probably under some additional flag), but for now I think
this code will do just fine.

[xiyuan, 2015/03/22 00:12:01]

Okay.

I point out ForEachStoragePartition because it fits better with
CleanSigninProfile and we could avoid passing in a WebContents.

+                        base::Bind(&GetWebViewPartition, &partition_set));
+  base::Closure barrier_closure =
+      base::BarrierClosure(partition_set.size(), on_clear_callback);
+  for (const auto& partition : partition_set) {
+    partition->ClearData(
+        content::StoragePartition::REMOVE_DATA_MASK_ALL,
+        content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL, GURL(),
+        content::StoragePartition::OriginMatcherFunction(), base::Time(),
+        base::Time::Now(), barrier_closure);
+  }
+}
+
 }  // anonymous namespace
 
 // static
 bool ProfileHelper::enable_profile_to_user_testing = false;
 bool ProfileHelper::always_return_primary_user_for_testing = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // ProfileHelper, public
 
 ProfileHelper::ProfileHelper()
@@ skipping 129 matching lines @@
 }
 
 base::FilePath ProfileHelper::GetActiveUserProfileDir() {
   return ProfileHelper::GetUserProfileDir(active_user_id_hash_);
 }
 
 void ProfileHelper::Initialize() {
   user_manager::UserManager::Get()->AddSessionStateObserver(this);
 }
 
-void ProfileHelper::ClearSigninProfile(const base::Closure& on_clear_callback) {
-  on_clear_callbacks_.push_back(on_clear_callback);
+void ProfileHelper::ClearSigninProfile(const base::Closure& on_clear_callback,
+                                       content::WebContents* webview_contents) {
+  on_clear_callbacks_.push_back(
+      webview_contents
+          ? base::Bind(&ClearContentsData, webview_contents, on_clear_callback)
+          : on_clear_callback);
   if (signin_profile_clear_requested_)
     return;
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   // Check if signin profile was loaded.
   if (!profile_manager->GetProfileByPath(GetSigninProfileDir())) {
     OnBrowsingDataRemoverDone();
     return;
   }
   signin_profile_clear_requested_ = true;
   BrowsingDataRemover* remover =
@@ skipping 131 matching lines @@
 void ProfileHelper::OnSessionRestoreStateChanged(
     Profile* user_profile,
     OAuth2LoginManager::SessionRestoreState state) {
   if (state == OAuth2LoginManager::SESSION_RESTORE_DONE ||
       state == OAuth2LoginManager::SESSION_RESTORE_FAILED ||
       state == OAuth2LoginManager::SESSION_RESTORE_CONNECTION_FAILED) {
     chromeos::OAuth2LoginManager* login_manager =
         chromeos::OAuth2LoginManagerFactory::GetInstance()->
             GetForProfile(user_profile);
     login_manager->RemoveObserver(this);
-    ClearSigninProfile(base::Closure());
+    ClearSigninProfile(base::Closure(), nullptr);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ProfileHelper, UserManager::UserSessionStateObserver implementation:
 
 void ProfileHelper::ActiveUserHashChanged(const std::string& hash) {
   active_user_id_hash_ = hash;
 }
 
@@ skipping 19 matching lines @@
   user_to_profile_for_testing_[user] = profile;
 }
 
 // static
 std::string ProfileHelper::GetUserIdHashByUserIdForTesting(
     const std::string& user_id) {
   return user_id + kUserIdHashSuffix;
 }
 
 }  // namespace chromeos