1 // Copyright 2014 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/safe_browsing/incident_reporting/last_download_finder.h" 6 7 #include <algorithm> 8 #include <functional> 9 #include <utility> 10 11 #include "base/bind.h" 12 #include "base/macros.h" 13 #include "base/prefs/pref_service.h" 14 #include "chrome/browser/browser_process.h" 15 #include "chrome/browser/chrome_notification_types.h" 16 #include "chrome/browser/history/history_service.h" 17 #include "chrome/browser/history/history_service_factory.h" 18 #include "chrome/browser/profiles/profile_manager.h" 19 #include "chrome/common/pref_names.h" 20 #include "chrome/common/safe_browsing/csd.pb.h" 21 #include "chrome/common/safe_browsing/download_protection_util.h" 22 #include "content/public/browser/download_item.h" 23 #include "content/public/browser/notification_details.h" 24 #include "content/public/browser/notification_service.h" 25 #include "content/public/browser/notification_source.h" 26 27 namespace safe_browsing { 28 29 namespace { 30 31 // Returns true if |first| is more recent than |second|, preferring opened over 32 // non-opened for downloads that completed at the same time (extraordinarily 33 // unlikely). Only files that look like some kind of executable are considered. 34 bool IsMoreInterestingThan(const history::DownloadRow& first, 35 const history::DownloadRow& second) { 36 if (first.end_time < second.end_time) 37 return false; 38 // TODO(grt): Peek into archives to see if they contain binaries; 39 // http://crbug.com/386915. 40 if (!download_protection_util::IsBinaryFile(first.target_path) || 41 download_protection_util::IsArchiveFile(first.target_path)) { 42 return false; 43 } 44 return (first.end_time != second.end_time || 45 (first.opened && !second.opened)); 46 } 47 48 // Returns a pointer to the most interesting completed download in |downloads|. 49 const history::DownloadRow* FindMostInteresting( 50 const std::vector<history::DownloadRow>& downloads) { 51 const history::DownloadRow* most_recent_row = NULL; 52 for (size_t i = 0; i < downloads.size(); ++i) { 53 const history::DownloadRow& row = downloads[i]; 54 // Ignore incomplete downloads. 55 if (row.state != content::DownloadItem::COMPLETE) 56 continue; 57 if (!most_recent_row || IsMoreInterestingThan(row, *most_recent_row)) 58 most_recent_row = &row; 59 } 60 return most_recent_row; 61 } 62 63 // Populates the |details| protobuf with information pertaining to |download|. 64 void PopulateDetails(const history::DownloadRow& download, 65 ClientIncidentReport_DownloadDetails* details) { 66 ClientDownloadRequest* download_request = details->mutable_download(); 67 download_request->set_url(download.url_chain.back().spec()); 68 // digests is a required field, so force it to exist. 69 // TODO(grt): Include digests in reports; http://crbug.com/389123. 70 ignore_result(download_request->mutable_digests()); 71 download_request->set_length(download.received_bytes); 72 for (size_t i = 0; i < download.url_chain.size(); ++i) { 73 const GURL& url = download.url_chain[i]; 74 ClientDownloadRequest_Resource* resource = 75 download_request->add_resources(); 76 resource->set_url(url.spec()); 77 if (i != download.url_chain.size() - 1) { // An intermediate redirect. 78 resource->set_type(ClientDownloadRequest::DOWNLOAD_REDIRECT); 79 } else { // The final download URL. 80 resource->set_type(ClientDownloadRequest::DOWNLOAD_URL); 81 if (!download.referrer_url.is_empty()) 82 resource->set_referrer(download.referrer_url.spec()); 83 } 84 } 85 download_request->set_file_basename( 86 download.target_path.BaseName().AsUTF8Unsafe()); 87 download_request->set_download_type( 88 download_protection_util::GetDownloadType(download.target_path)); 89 download_request->set_locale( 90 g_browser_process->local_state()->GetString(prefs::kApplicationLocale)); 91 92 details->set_download_time_msec(download.end_time.ToJavaTime()); 93 // Opened time is unknown for now, so use the download time if the file was 94 // opened in Chrome. 95 if (download.opened) 96 details->set_open_time_msec(download.end_time.ToJavaTime()); 97 } 98 99 } // namespace 100 101 LastDownloadFinder::~LastDownloadFinder() { 102 } 103 104 // static 105 scoped_ptr<LastDownloadFinder> LastDownloadFinder::Create( 106 const LastDownloadCallback& callback) { 107 scoped_ptr<LastDownloadFinder> finder(make_scoped_ptr(new LastDownloadFinder( 108 g_browser_process->profile_manager()->GetLoadedProfiles(), callback))); 109 // Return NULL if there is no work to do. 110 if (finder->profiles_.empty()) 111 return scoped_ptr<LastDownloadFinder>(); 112 return finder.Pass(); 113 } 114 115 LastDownloadFinder::LastDownloadFinder() : weak_ptr_factory_(this) { 116 } 117 118 LastDownloadFinder::LastDownloadFinder(const std::vector<Profile*>& profiles, 119 const LastDownloadCallback& callback) 120 : callback_(callback), weak_ptr_factory_(this) { 121 // Observe profile lifecycle events so that the finder can begin or abandon 122 // the search in profiles while it is running. 123 notification_registrar_.Add(this, 124 chrome::NOTIFICATION_PROFILE_ADDED, 125 content::NotificationService::AllSources()); 126 notification_registrar_.Add(this, 127 chrome::NOTIFICATION_HISTORY_LOADED, 128 content::NotificationService::AllSources()); 129 notification_registrar_.Add(this, 130 chrome::NOTIFICATION_PROFILE_DESTROYED, 131 content::NotificationService::AllSources()); 132 133 // Begin the seach for all given profiles. 134 std::for_each( 135 profiles.begin(), 136 profiles.end(), 137 std::bind1st(std::mem_fun(&LastDownloadFinder::SearchInProfile), this)); 138 } 139 140 void LastDownloadFinder::SearchInProfile(Profile* profile) { 141 // Do not look in OTR profiles or in profiles that do not participate in 142 // safe browsing. 143 if (profile->IsOffTheRecord() || 144 !profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled)) { 145 return; 146 } 147 148 // Exit early if already processing this profile. This could happen if, for 149 // example, NOTIFICATION_PROFILE_ADDED arrives after construction while 150 // waiting for NOTIFICATION_HISTORY_LOADED. 151 if (std::find(profiles_.begin(), profiles_.end(), profile) != 152 profiles_.end()) { 153 return; 154 } 155 156 HistoryService* history_service = 157 HistoryServiceFactory::GetForProfile(profile, Profile::IMPLICIT_ACCESS); 158 // No history service is returned for profiles that do not save history. 159 if (!history_service) 160 return; 161 162 profiles_.push_back(profile); 163 if (history_service->BackendLoaded()) { 164 history_service->QueryDownloads( 165 base::Bind(&LastDownloadFinder::OnDownloadQuery, 166 weak_ptr_factory_.GetWeakPtr(), 167 profile)); 168 } // else wait until history is loaded. 169 } 170 171 void LastDownloadFinder::OnProfileHistoryLoaded( 172 Profile* profile, 173 HistoryService* history_service) { 174 if (std::find(profiles_.begin(), profiles_.end(), profile) != 175 profiles_.end()) { 176 history_service->QueryDownloads( 177 base::Bind(&LastDownloadFinder::OnDownloadQuery, 178 weak_ptr_factory_.GetWeakPtr(), 179 profile)); 180 } 181 } 182 183 void LastDownloadFinder::AbandonSearchInProfile(Profile* profile) { 184 // |profile| may not be present in the set of profiles. 185 std::vector<Profile*>::iterator it = 186 std::find(profiles_.begin(), profiles_.end(), profile); 187 if (it != profiles_.end()) 188 RemoveProfileAndReportIfDone(it); 189 } 190 191 void LastDownloadFinder::OnDownloadQuery( 192 Profile* profile, 193 scoped_ptr<std::vector<history::DownloadRow> > downloads) { 194 // Early-exit if the history search for this profile was abandoned. 195 std::vector<Profile*>::iterator it = 196 std::find(profiles_.begin(), profiles_.end(), profile); 197 if (it == profiles_.end()) 198 return; 199 200 // Find the most recent from this profile and use it if it's better than 201 // anything else found so far. 202 const history::DownloadRow* profile_best = FindMostInteresting(*downloads); 203 if (profile_best && IsMoreInterestingThan(*profile_best, most_recent_row_)) 204 most_recent_row_ = *profile_best; 205 206 RemoveProfileAndReportIfDone(it); 207 } 208 209 void LastDownloadFinder::RemoveProfileAndReportIfDone( 210 std::vector<Profile*>::iterator it) { 211 DCHECK(it != profiles_.end()); 212 213 *it = profiles_.back(); 214 profiles_.resize(profiles_.size() - 1); 215 216 // Finish processing if all results are in. 217 if (profiles_.empty()) 218 ReportResults(); 219 // Do not touch this instance after reporting results. 220 } 221 222 void LastDownloadFinder::ReportResults() { 223 DCHECK(profiles_.empty()); 224 if (most_recent_row_.end_time.is_null()) { 225 callback_.Run(scoped_ptr<ClientIncidentReport_DownloadDetails>()); 226 // Do not touch this instance after running the callback, since it may have 227 // been deleted. 228 } else { 229 scoped_ptr<ClientIncidentReport_DownloadDetails> details( 230 new ClientIncidentReport_DownloadDetails()); 231 PopulateDetails(most_recent_row_, details.get()); 232 callback_.Run(details.Pass()); 233 // Do not touch this instance after running the callback, since it may have 234 // been deleted. 235 } 236 } 237 238 void LastDownloadFinder::Observe(int type, 239 const content::NotificationSource& source, 240 const content::NotificationDetails& details) { 241 switch (type) { 242 case chrome::NOTIFICATION_PROFILE_ADDED: 243 SearchInProfile(content::Source<Profile>(source).ptr()); 244 break; 245 case chrome::NOTIFICATION_HISTORY_LOADED: 246 OnProfileHistoryLoaded(content::Source<Profile>(source).ptr(), 247 content::Details<HistoryService>(details).ptr()); 248 break; 249 case chrome::NOTIFICATION_PROFILE_DESTROYED: 250 AbandonSearchInProfile(content::Source<Profile>(source).ptr()); 251 break; 252 default: 253 break; 254 } 255 } 256 257 } // namespace safe_browsing 258
