1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/profiles/profile_destroyer.h" 6 7 #include "base/bind.h" 8 #include "base/debug/trace_event.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/message_loop/message_loop.h" 11 #include "chrome/browser/profiles/profile.h" 12 #include "content/public/browser/render_process_host.h" 13 14 namespace { 15 16 #if defined(OS_ANDROID) 17 // Set the render host waiting time to 5s on Android, that's the same 18 // as an "Application Not Responding" timeout. 19 const int64 kTimerDelaySeconds = 5; 20 #else 21 const int64 kTimerDelaySeconds = 1; 22 #endif 23 24 } // namespace 25 26 ProfileDestroyer::DestroyerSet* ProfileDestroyer::pending_destroyers_ = NULL; 27 28 // static 29 void ProfileDestroyer::DestroyProfileWhenAppropriate(Profile* const profile) { 30 TRACE_EVENT0("shutdown", "ProfileDestroyer::DestroyProfileWhenAppropriate"); 31 32 DCHECK(profile); 33 profile->MaybeSendDestroyedNotification(); 34 35 HostSet hosts; 36 // Testing profiles can simply be deleted directly. Some tests don't setup 37 // RenderProcessHost correctly and don't necessary run on the UI thread 38 // anyway, so we can't use the AllHostIterator. 39 if (profile->AsTestingProfile() == NULL) { 40 GetHostsForProfile(profile, &hosts); 41 if (!profile->IsOffTheRecord() && profile->HasOffTheRecordProfile()) 42 GetHostsForProfile(profile->GetOffTheRecordProfile(), &hosts); 43 } 44 // Generally, !hosts.empty() means that there is a leak in a render process 45 // host that MUST BE FIXED!!! 46 // 47 // However, off-the-record profiles are destroyed before their 48 // RenderProcessHosts in order to erase private data quickly, and 49 // RenderProcessHostImpl::Release() avoids destroying RenderProcessHosts in 50 // --single-process mode to avoid race conditions. 51 DCHECK(hosts.empty() || profile->IsOffTheRecord() || 52 content::RenderProcessHost::run_renderer_in_process()) << \ 53 "Profile still has " << hosts.size() << " hosts"; 54 // Note that we still test for !profile->IsOffTheRecord here even though we 55 // DCHECK'd above because we want to protect Release builds against this even 56 // we need to identify if there are leaks when we run Debug builds. 57 if (hosts.empty() || !profile->IsOffTheRecord()) { 58 if (profile->IsOffTheRecord()) 59 profile->GetOriginalProfile()->DestroyOffTheRecordProfile(); 60 else 61 delete profile; 62 } else { 63 // The instance will destroy itself once all render process hosts referring 64 // to it are properly terminated. 65 new ProfileDestroyer(profile, &hosts); 66 } 67 } 68 69 // This can be called to cancel any pending destruction and destroy the profile 70 // now, e.g., if the parent profile is being destroyed while the incognito one 71 // still pending... 72 void ProfileDestroyer::DestroyOffTheRecordProfileNow(Profile* const profile) { 73 DCHECK(profile); 74 DCHECK(profile->IsOffTheRecord()); 75 if (pending_destroyers_) { 76 for (DestroyerSet::iterator i = pending_destroyers_->begin(); 77 i != pending_destroyers_->end(); ++i) { 78 if ((*i)->profile_ == profile) { 79 // We want to signal this in debug builds so that we don't lose sight of 80 // these potential leaks, but we handle it in release so that we don't 81 // crash or corrupt profile data on disk. 82 NOTREACHED() << "A render process host wasn't destroyed early enough."; 83 (*i)->profile_ = NULL; 84 break; 85 } 86 } 87 } 88 DCHECK(profile->GetOriginalProfile()); 89 profile->GetOriginalProfile()->DestroyOffTheRecordProfile(); 90 } 91 92 ProfileDestroyer::ProfileDestroyer(Profile* const profile, HostSet* hosts) 93 : timer_(false, false), 94 num_hosts_(0), 95 profile_(profile), 96 weak_ptr_factory_(this) { 97 if (pending_destroyers_ == NULL) 98 pending_destroyers_ = new DestroyerSet; 99 pending_destroyers_->insert(this); 100 for (HostSet::iterator i = hosts->begin(); i != hosts->end(); ++i) { 101 (*i)->AddObserver(this); 102 // For each of the observations, we bump up our reference count. 103 // It will go back to 0 and free us when all hosts are terminated. 104 ++num_hosts_; 105 } 106 // If we are going to wait for render process hosts, we don't want to do it 107 // for longer than kTimerDelaySeconds. 108 if (num_hosts_) { 109 timer_.Start(FROM_HERE, 110 base::TimeDelta::FromSeconds(kTimerDelaySeconds), 111 base::Bind(&ProfileDestroyer::DestroyProfile, 112 weak_ptr_factory_.GetWeakPtr())); 113 } 114 } 115 116 ProfileDestroyer::~ProfileDestroyer() { 117 // Check again, in case other render hosts were added while we were 118 // waiting for the previous ones to go away... 119 if (profile_) 120 DestroyProfileWhenAppropriate(profile_); 121 122 // Don't wait for pending registrations, if any, these hosts are buggy. 123 // Note: this can happen, but if so, it's better to crash here than wait 124 // for the host to dereference a deleted Profile. http://crbug.com/248625 125 CHECK_EQ(0U, num_hosts_) << "Some render process hosts were not " 126 << "destroyed early enough!"; 127 128 DCHECK(pending_destroyers_ != NULL); 129 DestroyerSet::iterator iter = pending_destroyers_->find(this); 130 DCHECK(iter != pending_destroyers_->end()); 131 pending_destroyers_->erase(iter); 132 if (pending_destroyers_->empty()) { 133 delete pending_destroyers_; 134 pending_destroyers_ = NULL; 135 } 136 } 137 138 void ProfileDestroyer::RenderProcessHostDestroyed( 139 content::RenderProcessHost* host) { 140 DCHECK(num_hosts_ > 0); 141 --num_hosts_; 142 if (num_hosts_ == 0) { 143 // Delay the destruction one step further in case other observers need to 144 // look at the profile attached to the host. 145 base::MessageLoop::current()->PostTask( 146 FROM_HERE, base::Bind( 147 &ProfileDestroyer::DestroyProfile, weak_ptr_factory_.GetWeakPtr())); 148 } 149 } 150 151 void ProfileDestroyer::DestroyProfile() { 152 // We might have been cancelled externally before the timer expired. 153 if (!profile_) { 154 delete this; 155 return; 156 } 157 158 DCHECK(profile_->IsOffTheRecord()); 159 DCHECK(profile_->GetOriginalProfile()); 160 profile_->GetOriginalProfile()->DestroyOffTheRecordProfile(); 161 profile_ = NULL; 162 163 // And stop the timer so we can be released early too. 164 timer_.Stop(); 165 166 delete this; 167 } 168 169 // static 170 bool ProfileDestroyer::GetHostsForProfile( 171 Profile* const profile, HostSet* hosts) { 172 for (content::RenderProcessHost::iterator iter( 173 content::RenderProcessHost::AllHostsIterator()); 174 !iter.IsAtEnd(); iter.Advance()) { 175 content::RenderProcessHost* render_process_host = iter.GetCurrentValue(); 176 if (render_process_host && 177 render_process_host->GetBrowserContext() == profile) { 178 hosts->insert(render_process_host); 179 } 180 } 181 return !hosts->empty(); 182 } 183