// Copyright (c) 2011 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/webdata/web_data_service.h" #include "base/message_loop.h" #include "base/stl_util-inl.h" #include "base/task.h" #include "base/threading/thread.h" #include "chrome/browser/autofill/autofill_profile.h" #include "chrome/browser/autofill/credit_card.h" #include "chrome/browser/search_engines/template_url.h" #include "chrome/browser/ui/profile_error_dialog.h" #include "chrome/browser/webdata/autofill_change.h" #include "chrome/browser/webdata/autofill_entry.h" #include "chrome/browser/webdata/web_database.h" #include "chrome/common/chrome_constants.h" #include "content/common/notification_details.h" #include "content/common/notification_service.h" #include "content/common/notification_source.h" #include "content/common/notification_type.h" #include "grit/chromium_strings.h" #include "grit/generated_resources.h" #include "third_party/skia/include/core/SkBitmap.h" #include "webkit/glue/form_field.h" #include "webkit/glue/password_form.h" //////////////////////////////////////////////////////////////////////////////// // // WebDataService implementation. // //////////////////////////////////////////////////////////////////////////////// using base::Time; using webkit_glue::FormField; using webkit_glue::PasswordForm; WDAppImagesResult::WDAppImagesResult() : has_all_images(false) {} WDAppImagesResult::~WDAppImagesResult() {} WDKeywordsResult::WDKeywordsResult() : default_search_provider_id(0), builtin_keyword_version(0) { } WDKeywordsResult::~WDKeywordsResult() {} WebDataService::WebDataService() : is_running_(false), db_(NULL), failed_init_(false), should_commit_(false), next_request_handle_(1), main_loop_(MessageLoop::current()) { } bool WebDataService::Init(const FilePath& profile_path) { FilePath path = profile_path; path = path.Append(chrome::kWebDataFilename); return InitWithPath(path); } void WebDataService::Shutdown() { UnloadDatabase(); } bool WebDataService::IsRunning() const { return is_running_; } void WebDataService::UnloadDatabase() { ScheduleTask(NewRunnableMethod(this, &WebDataService::ShutdownDatabase)); } void WebDataService::CancelRequest(Handle h) { base::AutoLock l(pending_lock_); RequestMap::iterator i = pending_requests_.find(h); if (i == pending_requests_.end()) { NOTREACHED() << "Canceling a nonexistent web data service request"; return; } i->second->Cancel(); } bool WebDataService::IsDatabaseLoaded() { return db_ != NULL; } WebDatabase* WebDataService::GetDatabase() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB)); return db_; } ////////////////////////////////////////////////////////////////////////////// // // Keywords. // ////////////////////////////////////////////////////////////////////////////// void WebDataService::AddKeyword(const TemplateURL& url) { // Ensure that the keyword is already generated (and cached) before caching // the TemplateURL for use on another keyword. url.EnsureKeyword(); GenericRequest<TemplateURL>* request = new GenericRequest<TemplateURL>(this, GetNextRequestHandle(), NULL, url); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::AddKeywordImpl, request)); } void WebDataService::RemoveKeyword(const TemplateURL& url) { GenericRequest<TemplateURLID>* request = new GenericRequest<TemplateURLID>(this, GetNextRequestHandle(), NULL, url.id()); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::RemoveKeywordImpl, request)); } void WebDataService::UpdateKeyword(const TemplateURL& url) { // Ensure that the keyword is already generated (and cached) before caching // the TemplateURL for use on another keyword. url.EnsureKeyword(); GenericRequest<TemplateURL>* request = new GenericRequest<TemplateURL>(this, GetNextRequestHandle(), NULL, url); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::UpdateKeywordImpl, request)); } WebDataService::Handle WebDataService::GetKeywords( WebDataServiceConsumer* consumer) { WebDataRequest* request = new WebDataRequest(this, GetNextRequestHandle(), consumer); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::GetKeywordsImpl, request)); return request->GetHandle(); } void WebDataService::SetDefaultSearchProvider(const TemplateURL* url) { GenericRequest<TemplateURLID>* request = new GenericRequest<TemplateURLID>(this, GetNextRequestHandle(), NULL, url ? url->id() : 0); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::SetDefaultSearchProviderImpl, request)); } void WebDataService::SetBuiltinKeywordVersion(int version) { GenericRequest<int>* request = new GenericRequest<int>(this, GetNextRequestHandle(), NULL, version); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::SetBuiltinKeywordVersionImpl, request)); } ////////////////////////////////////////////////////////////////////////////// // // Web Apps // ////////////////////////////////////////////////////////////////////////////// void WebDataService::SetWebAppImage(const GURL& app_url, const SkBitmap& image) { GenericRequest2<GURL, SkBitmap>* request = new GenericRequest2<GURL, SkBitmap>(this, GetNextRequestHandle(), NULL, app_url, image); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::SetWebAppImageImpl, request)); } void WebDataService::SetWebAppHasAllImages(const GURL& app_url, bool has_all_images) { GenericRequest2<GURL, bool>* request = new GenericRequest2<GURL, bool>(this, GetNextRequestHandle(), NULL, app_url, has_all_images); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::SetWebAppHasAllImagesImpl, request)); } void WebDataService::RemoveWebApp(const GURL& app_url) { GenericRequest<GURL>* request = new GenericRequest<GURL>(this, GetNextRequestHandle(), NULL, app_url); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::RemoveWebAppImpl, request)); } WebDataService::Handle WebDataService::GetWebAppImages( const GURL& app_url, WebDataServiceConsumer* consumer) { GenericRequest<GURL>* request = new GenericRequest<GURL>(this, GetNextRequestHandle(), consumer, app_url); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::GetWebAppImagesImpl, request)); return request->GetHandle(); } //////////////////////////////////////////////////////////////////////////////// // // Token Service // //////////////////////////////////////////////////////////////////////////////// void WebDataService::SetTokenForService(const std::string& service, const std::string& token) { GenericRequest2<std::string, std::string>* request = new GenericRequest2<std::string, std::string>( this, GetNextRequestHandle(), NULL, service, token); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::SetTokenForServiceImpl, request)); } void WebDataService::RemoveAllTokens() { GenericRequest<std::string>* request = new GenericRequest<std::string>( this, GetNextRequestHandle(), NULL, std::string()); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::RemoveAllTokensImpl, request)); } // Null on failure. Success is WDResult<std::string> WebDataService::Handle WebDataService::GetAllTokens( WebDataServiceConsumer* consumer) { GenericRequest<std::string>* request = new GenericRequest<std::string>( this, GetNextRequestHandle(), consumer, std::string()); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::GetAllTokensImpl, request)); return request->GetHandle(); } //////////////////////////////////////////////////////////////////////////////// // // Password manager. // //////////////////////////////////////////////////////////////////////////////// void WebDataService::AddLogin(const PasswordForm& form) { GenericRequest<PasswordForm>* request = new GenericRequest<PasswordForm>(this, GetNextRequestHandle(), NULL, form); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::AddLoginImpl, request)); } void WebDataService::UpdateLogin(const PasswordForm& form) { GenericRequest<PasswordForm>* request = new GenericRequest<PasswordForm>(this, GetNextRequestHandle(), NULL, form); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::UpdateLoginImpl, request)); } void WebDataService::RemoveLogin(const PasswordForm& form) { GenericRequest<PasswordForm>* request = new GenericRequest<PasswordForm>(this, GetNextRequestHandle(), NULL, form); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::RemoveLoginImpl, request)); } void WebDataService::RemoveLoginsCreatedBetween(const Time& delete_begin, const Time& delete_end) { GenericRequest2<Time, Time>* request = new GenericRequest2<Time, Time>(this, GetNextRequestHandle(), NULL, delete_begin, delete_end); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::RemoveLoginsCreatedBetweenImpl, request)); } void WebDataService::RemoveLoginsCreatedAfter(const Time& delete_begin) { RemoveLoginsCreatedBetween(delete_begin, Time()); } WebDataService::Handle WebDataService::GetLogins( const PasswordForm& form, WebDataServiceConsumer* consumer) { GenericRequest<PasswordForm>* request = new GenericRequest<PasswordForm>(this, GetNextRequestHandle(), consumer, form); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::GetLoginsImpl, request)); return request->GetHandle(); } WebDataService::Handle WebDataService::GetAutofillableLogins( WebDataServiceConsumer* consumer) { WebDataRequest* request = new WebDataRequest(this, GetNextRequestHandle(), consumer); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::GetAutofillableLoginsImpl, request)); return request->GetHandle(); } WebDataService::Handle WebDataService::GetBlacklistLogins( WebDataServiceConsumer* consumer) { WebDataRequest* request = new WebDataRequest(this, GetNextRequestHandle(), consumer); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::GetBlacklistLoginsImpl, request)); return request->GetHandle(); } //////////////////////////////////////////////////////////////////////////////// // // Autofill. // //////////////////////////////////////////////////////////////////////////////// void WebDataService::AddFormFields( const std::vector<FormField>& fields) { GenericRequest<std::vector<FormField> >* request = new GenericRequest<std::vector<FormField> >( this, GetNextRequestHandle(), NULL, fields); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::AddFormElementsImpl, request)); } WebDataService::Handle WebDataService::GetFormValuesForElementName( const string16& name, const string16& prefix, int limit, WebDataServiceConsumer* consumer) { WebDataRequest* request = new WebDataRequest(this, GetNextRequestHandle(), consumer); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::GetFormValuesForElementNameImpl, request, name, prefix, limit)); return request->GetHandle(); } void WebDataService::RemoveFormElementsAddedBetween(const Time& delete_begin, const Time& delete_end) { GenericRequest2<Time, Time>* request = new GenericRequest2<Time, Time>(this, GetNextRequestHandle(), NULL, delete_begin, delete_end); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::RemoveFormElementsAddedBetweenImpl, request)); } void WebDataService::RemoveFormValueForElementName( const string16& name, const string16& value) { GenericRequest2<string16, string16>* request = new GenericRequest2<string16, string16>(this, GetNextRequestHandle(), NULL, name, value); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::RemoveFormValueForElementNameImpl, request)); } void WebDataService::AddAutofillProfile(const AutofillProfile& profile) { GenericRequest<AutofillProfile>* request = new GenericRequest<AutofillProfile>( this, GetNextRequestHandle(), NULL, profile); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::AddAutofillProfileImpl, request)); } void WebDataService::UpdateAutofillProfile(const AutofillProfile& profile) { GenericRequest<AutofillProfile>* request = new GenericRequest<AutofillProfile>( this, GetNextRequestHandle(), NULL, profile); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::UpdateAutofillProfileImpl, request)); } void WebDataService::RemoveAutofillProfile(const std::string& guid) { GenericRequest<std::string>* request = new GenericRequest<std::string>( this, GetNextRequestHandle(), NULL, guid); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::RemoveAutofillProfileImpl, request)); } WebDataService::Handle WebDataService::GetAutofillProfiles( WebDataServiceConsumer* consumer) { WebDataRequest* request = new WebDataRequest(this, GetNextRequestHandle(), consumer); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::GetAutofillProfilesImpl, request)); return request->GetHandle(); } void WebDataService::EmptyMigrationTrash(bool notify_sync) { GenericRequest<bool>* request = new GenericRequest<bool>( this, GetNextRequestHandle(), NULL, notify_sync); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::EmptyMigrationTrashImpl, request)); } void WebDataService::AddCreditCard(const CreditCard& credit_card) { GenericRequest<CreditCard>* request = new GenericRequest<CreditCard>( this, GetNextRequestHandle(), NULL, credit_card); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::AddCreditCardImpl, request)); } void WebDataService::UpdateCreditCard(const CreditCard& credit_card) { GenericRequest<CreditCard>* request = new GenericRequest<CreditCard>( this, GetNextRequestHandle(), NULL, credit_card); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::UpdateCreditCardImpl, request)); } void WebDataService::RemoveCreditCard(const std::string& guid) { GenericRequest<std::string>* request = new GenericRequest<std::string>( this, GetNextRequestHandle(), NULL, guid); RegisterRequest(request); ScheduleTask(NewRunnableMethod(this, &WebDataService::RemoveCreditCardImpl, request)); } WebDataService::Handle WebDataService::GetCreditCards( WebDataServiceConsumer* consumer) { WebDataRequest* request = new WebDataRequest(this, GetNextRequestHandle(), consumer); RegisterRequest(request); ScheduleTask( NewRunnableMethod(this, &WebDataService::GetCreditCardsImpl, request)); return request->GetHandle(); } void WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetween( const Time& delete_begin, const Time& delete_end) { GenericRequest2<Time, Time>* request = new GenericRequest2<Time, Time>(this, GetNextRequestHandle(), NULL, delete_begin, delete_end); RegisterRequest(request); ScheduleTask(NewRunnableMethod( this, &WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetweenImpl, request)); } WebDataService::~WebDataService() { if (is_running_ && db_) { DLOG_ASSERT("WebDataService dtor called without Shutdown"); } } bool WebDataService::InitWithPath(const FilePath& path) { path_ = path; is_running_ = true; ScheduleTask(NewRunnableMethod(this, &WebDataService::InitializeDatabaseIfNecessary)); return true; } void WebDataService::RequestCompleted(Handle h) { pending_lock_.Acquire(); RequestMap::iterator i = pending_requests_.find(h); if (i == pending_requests_.end()) { NOTREACHED() << "Request completed called for an unknown request"; pending_lock_.Release(); return; } // Take ownership of the request object and remove it from the map. scoped_ptr<WebDataRequest> request(i->second); pending_requests_.erase(i); pending_lock_.Release(); // Notify the consumer if needed. WebDataServiceConsumer* consumer; if (!request->IsCancelled() && (consumer = request->GetConsumer())) { consumer->OnWebDataServiceRequestDone(request->GetHandle(), request->GetResult()); } else { // Nobody is taken ownership of the result, either because it is canceled // or there is no consumer. Destroy results that require special handling. WDTypedResult const *result = request->GetResult(); if (result) { if (result->GetType() == AUTOFILL_PROFILES_RESULT) { const WDResult<std::vector<AutofillProfile*> >* r = static_cast<const WDResult<std::vector<AutofillProfile*> >*>( result); std::vector<AutofillProfile*> profiles = r->GetValue(); STLDeleteElements(&profiles); } else if (result->GetType() == AUTOFILL_CREDITCARDS_RESULT) { const WDResult<std::vector<CreditCard*> >* r = static_cast<const WDResult<std::vector<CreditCard*> >*>(result); std::vector<CreditCard*> credit_cards = r->GetValue(); STLDeleteElements(&credit_cards); } } } } void WebDataService::RegisterRequest(WebDataRequest* request) { base::AutoLock l(pending_lock_); pending_requests_[request->GetHandle()] = request; } //////////////////////////////////////////////////////////////////////////////// // // The following methods are executed in Chrome_WebDataThread. // //////////////////////////////////////////////////////////////////////////////// void WebDataService::DBInitFailed(sql::InitStatus init_status) { ShowProfileErrorDialog( (init_status == sql::INIT_FAILURE) ? IDS_COULDNT_OPEN_PROFILE_ERROR : IDS_PROFILE_TOO_NEW_ERROR); } void WebDataService::InitializeDatabaseIfNecessary() { if (db_ || failed_init_ || path_.empty()) return; // In the rare case where the db fails to initialize a dialog may get shown // that blocks the caller, yet allows other messages through. For this reason // we only set db_ to the created database if creation is successful. That // way other methods won't do anything as db_ is still NULL. WebDatabase* db = new WebDatabase(); sql::InitStatus init_status = db->Init(path_); if (init_status != sql::INIT_OK) { LOG(ERROR) << "Cannot initialize the web database: " << init_status; failed_init_ = true; delete db; if (main_loop_) { main_loop_->PostTask(FROM_HERE, NewRunnableMethod(this, &WebDataService::DBInitFailed, init_status)); } return; } BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, NewRunnableMethod(this, &WebDataService::NotifyDatabaseLoadedOnUIThread)); db_ = db; db_->BeginTransaction(); } void WebDataService::NotifyDatabaseLoadedOnUIThread() { // Notify that the database has been initialized. NotificationService::current()->Notify(NotificationType::WEB_DATABASE_LOADED, Source<WebDataService>(this), NotificationService::NoDetails()); } void WebDataService::ShutdownDatabase() { should_commit_ = false; if (db_) { db_->CommitTransaction(); delete db_; db_ = NULL; } } void WebDataService::Commit() { if (should_commit_) { should_commit_ = false; if (db_) { db_->CommitTransaction(); db_->BeginTransaction(); } } } void WebDataService::ScheduleTask(Task* t) { if (is_running_) BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, t); else NOTREACHED() << "Task scheduled after Shutdown()"; } void WebDataService::ScheduleCommit() { if (should_commit_ == false) { should_commit_ = true; ScheduleTask(NewRunnableMethod(this, &WebDataService::Commit)); } } int WebDataService::GetNextRequestHandle() { base::AutoLock l(pending_lock_); return ++next_request_handle_; } //////////////////////////////////////////////////////////////////////////////// // // Keywords implementation. // //////////////////////////////////////////////////////////////////////////////// void WebDataService::AddKeywordImpl(GenericRequest<TemplateURL>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { db_->GetKeywordTable()->AddKeyword(request->GetArgument()); ScheduleCommit(); } request->RequestComplete(); } void WebDataService::RemoveKeywordImpl( GenericRequest<TemplateURLID>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { DCHECK(request->GetArgument()); db_->GetKeywordTable()->RemoveKeyword(request->GetArgument()); ScheduleCommit(); } request->RequestComplete(); } void WebDataService::UpdateKeywordImpl(GenericRequest<TemplateURL>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (!db_->GetKeywordTable()->UpdateKeyword(request->GetArgument())) { NOTREACHED(); return; } ScheduleCommit(); } request->RequestComplete(); } void WebDataService::GetKeywordsImpl(WebDataRequest* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { WDKeywordsResult result; db_->GetKeywordTable()->GetKeywords(&result.keywords); result.default_search_provider_id = db_->GetKeywordTable()->GetDefaulSearchProviderID(); result.builtin_keyword_version = db_->GetKeywordTable()->GetBuitinKeywordVersion(); request->SetResult( new WDResult<WDKeywordsResult>(KEYWORDS_RESULT, result)); } request->RequestComplete(); } void WebDataService::SetDefaultSearchProviderImpl( GenericRequest<TemplateURLID>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (!db_->GetKeywordTable()->SetDefaultSearchProviderID( request->GetArgument())) { NOTREACHED(); return; } ScheduleCommit(); } request->RequestComplete(); } void WebDataService::SetBuiltinKeywordVersionImpl( GenericRequest<int>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (!db_->GetKeywordTable()->SetBuitinKeywordVersion( request->GetArgument())) { NOTREACHED(); return; } ScheduleCommit(); } request->RequestComplete(); } //////////////////////////////////////////////////////////////////////////////// // // Web Apps implementation. // //////////////////////////////////////////////////////////////////////////////// void WebDataService::SetWebAppImageImpl( GenericRequest2<GURL, SkBitmap>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { db_->GetWebAppsTable()->SetWebAppImage( request->GetArgument1(), request->GetArgument2()); ScheduleCommit(); } request->RequestComplete(); } void WebDataService::SetWebAppHasAllImagesImpl( GenericRequest2<GURL, bool>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { db_->GetWebAppsTable()->SetWebAppHasAllImages(request->GetArgument1(), request->GetArgument2()); ScheduleCommit(); } request->RequestComplete(); } void WebDataService::RemoveWebAppImpl(GenericRequest<GURL>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { db_->GetWebAppsTable()->RemoveWebApp(request->GetArgument()); ScheduleCommit(); } request->RequestComplete(); } void WebDataService::GetWebAppImagesImpl(GenericRequest<GURL>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { WDAppImagesResult result; result.has_all_images = db_->GetWebAppsTable()->GetWebAppHasAllImages(request->GetArgument()); db_->GetWebAppsTable()->GetWebAppImages( request->GetArgument(), &result.images); request->SetResult( new WDResult<WDAppImagesResult>(WEB_APP_IMAGES, result)); } request->RequestComplete(); } //////////////////////////////////////////////////////////////////////////////// // // Token Service implementation. // //////////////////////////////////////////////////////////////////////////////// // argument std::string is unused void WebDataService::RemoveAllTokensImpl( GenericRequest<std::string>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (db_->GetTokenServiceTable()->RemoveAllTokens()) { ScheduleCommit(); } } request->RequestComplete(); } void WebDataService::SetTokenForServiceImpl( GenericRequest2<std::string, std::string>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (db_->GetTokenServiceTable()->SetTokenForService( request->GetArgument1(), request->GetArgument2())) { ScheduleCommit(); } } request->RequestComplete(); } // argument is unused void WebDataService::GetAllTokensImpl( GenericRequest<std::string>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::map<std::string, std::string> map; db_->GetTokenServiceTable()->GetAllTokens(&map); request->SetResult( new WDResult<std::map<std::string, std::string> >(TOKEN_RESULT, map)); } request->RequestComplete(); } //////////////////////////////////////////////////////////////////////////////// // // Password manager implementation. // //////////////////////////////////////////////////////////////////////////////// void WebDataService::AddLoginImpl(GenericRequest<PasswordForm>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (db_->GetLoginsTable()->AddLogin(request->GetArgument())) ScheduleCommit(); } request->RequestComplete(); } void WebDataService::UpdateLoginImpl(GenericRequest<PasswordForm>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (db_->GetLoginsTable()->UpdateLogin(request->GetArgument())) ScheduleCommit(); } request->RequestComplete(); } void WebDataService::RemoveLoginImpl(GenericRequest<PasswordForm>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (db_->GetLoginsTable()->RemoveLogin(request->GetArgument())) ScheduleCommit(); } request->RequestComplete(); } void WebDataService::RemoveLoginsCreatedBetweenImpl( GenericRequest2<Time, Time>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { if (db_->GetLoginsTable()->RemoveLoginsCreatedBetween( request->GetArgument1(), request->GetArgument2())) { ScheduleCommit(); } } request->RequestComplete(); } void WebDataService::GetLoginsImpl(GenericRequest<PasswordForm>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::vector<PasswordForm*> forms; db_->GetLoginsTable()->GetLogins(request->GetArgument(), &forms); request->SetResult( new WDResult<std::vector<PasswordForm*> >(PASSWORD_RESULT, forms)); } request->RequestComplete(); } void WebDataService::GetAutofillableLoginsImpl(WebDataRequest* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::vector<PasswordForm*> forms; db_->GetLoginsTable()->GetAllLogins(&forms, false); request->SetResult( new WDResult<std::vector<PasswordForm*> >(PASSWORD_RESULT, forms)); } request->RequestComplete(); } void WebDataService::GetBlacklistLoginsImpl(WebDataRequest* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::vector<PasswordForm*> all_forms; db_->GetLoginsTable()->GetAllLogins(&all_forms, true); std::vector<PasswordForm*> blacklist_forms; for (std::vector<PasswordForm*>::iterator i = all_forms.begin(); i != all_forms.end(); ++i) { scoped_ptr<PasswordForm> form(*i); if (form->blacklisted_by_user) { blacklist_forms.push_back(form.release()); } } all_forms.clear(); request->SetResult( new WDResult<std::vector<PasswordForm*> >(PASSWORD_RESULT, blacklist_forms)); } request->RequestComplete(); } //////////////////////////////////////////////////////////////////////////////// // // Autofill implementation. // //////////////////////////////////////////////////////////////////////////////// void WebDataService::AddFormElementsImpl( GenericRequest<std::vector<FormField> >* request) { InitializeDatabaseIfNecessary(); const std::vector<FormField>& form_fields = request->GetArgument(); if (db_ && !request->IsCancelled()) { AutofillChangeList changes; if (!db_->GetAutofillTable()->AddFormFieldValues(form_fields, &changes)) { NOTREACHED(); return; } request->SetResult( new WDResult<AutofillChangeList>(AUTOFILL_CHANGES, changes)); ScheduleCommit(); // Post the notifications including the list of affected keys. // This is sent here so that work resulting from this notification will be // done on the DB thread, and not the UI thread. NotificationService::current()->Notify( NotificationType::AUTOFILL_ENTRIES_CHANGED, Source<WebDataService>(this), Details<AutofillChangeList>(&changes)); } request->RequestComplete(); } void WebDataService::GetFormValuesForElementNameImpl(WebDataRequest* request, const string16& name, const string16& prefix, int limit) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::vector<string16> values; db_->GetAutofillTable()->GetFormValuesForElementName( name, prefix, &values, limit); request->SetResult( new WDResult<std::vector<string16> >(AUTOFILL_VALUE_RESULT, values)); } request->RequestComplete(); } void WebDataService::RemoveFormElementsAddedBetweenImpl( GenericRequest2<Time, Time>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { AutofillChangeList changes; if (db_->GetAutofillTable()->RemoveFormElementsAddedBetween( request->GetArgument1(), request->GetArgument2(), &changes)) { if (!changes.empty()) { request->SetResult( new WDResult<AutofillChangeList>(AUTOFILL_CHANGES, changes)); // Post the notifications including the list of affected keys. // This is sent here so that work resulting from this notification // will be done on the DB thread, and not the UI thread. NotificationService::current()->Notify( NotificationType::AUTOFILL_ENTRIES_CHANGED, Source<WebDataService>(this), Details<AutofillChangeList>(&changes)); } ScheduleCommit(); } } request->RequestComplete(); } void WebDataService::RemoveFormValueForElementNameImpl( GenericRequest2<string16, string16>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { const string16& name = request->GetArgument1(); const string16& value = request->GetArgument2(); if (db_->GetAutofillTable()->RemoveFormElement(name, value)) { AutofillChangeList changes; changes.push_back(AutofillChange(AutofillChange::REMOVE, AutofillKey(name, value))); request->SetResult( new WDResult<AutofillChangeList>(AUTOFILL_CHANGES, changes)); ScheduleCommit(); // Post the notifications including the list of affected keys. NotificationService::current()->Notify( NotificationType::AUTOFILL_ENTRIES_CHANGED, Source<WebDataService>(this), Details<AutofillChangeList>(&changes)); } } request->RequestComplete(); } void WebDataService::AddAutofillProfileImpl( GenericRequest<AutofillProfile>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { const AutofillProfile& profile = request->GetArgument(); if (!db_->GetAutofillTable()->AddAutofillProfile(profile)) { NOTREACHED(); return; } ScheduleCommit(); // Send GUID-based notification. AutofillProfileChange change(AutofillProfileChange::ADD, profile.guid(), &profile); NotificationService::current()->Notify( NotificationType::AUTOFILL_PROFILE_CHANGED, Source<WebDataService>(this), Details<AutofillProfileChange>(&change)); } request->RequestComplete(); } void WebDataService::UpdateAutofillProfileImpl( GenericRequest<AutofillProfile>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { const AutofillProfile& profile = request->GetArgument(); // Only perform the update if the profile exists. It is currently // valid to try to update a missing profile. We simply drop the write and // the caller will detect this on the next refresh. AutofillProfile* original_profile = NULL; if (!db_->GetAutofillTable()->GetAutofillProfile(profile.guid(), &original_profile)) { request->RequestComplete(); return; } scoped_ptr<AutofillProfile> scoped_profile(original_profile); if (!db_->GetAutofillTable()->UpdateAutofillProfileMulti(profile)) { NOTREACHED(); return; } ScheduleCommit(); // Send GUID-based notification. AutofillProfileChange change(AutofillProfileChange::UPDATE, profile.guid(), &profile); NotificationService::current()->Notify( NotificationType::AUTOFILL_PROFILE_CHANGED, Source<WebDataService>(this), Details<AutofillProfileChange>(&change)); } request->RequestComplete(); } void WebDataService::RemoveAutofillProfileImpl( GenericRequest<std::string>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::string guid = request->GetArgument(); AutofillProfile* profile = NULL; if (!db_->GetAutofillTable()->GetAutofillProfile(guid, &profile)) { NOTREACHED(); return; } scoped_ptr<AutofillProfile> scoped_profile(profile); if (!db_->GetAutofillTable()->RemoveAutofillProfile(guid)) { NOTREACHED(); return; } ScheduleCommit(); // Send GUID-based notification. AutofillProfileChange change(AutofillProfileChange::REMOVE, guid, NULL); NotificationService::current()->Notify( NotificationType::AUTOFILL_PROFILE_CHANGED, Source<WebDataService>(this), Details<AutofillProfileChange>(&change)); } request->RequestComplete(); } void WebDataService::GetAutofillProfilesImpl(WebDataRequest* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::vector<AutofillProfile*> profiles; db_->GetAutofillTable()->GetAutofillProfiles(&profiles); request->SetResult( new WDResult<std::vector<AutofillProfile*> >(AUTOFILL_PROFILES_RESULT, profiles)); } request->RequestComplete(); } void WebDataService::EmptyMigrationTrashImpl( GenericRequest<bool>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { bool notify_sync = request->GetArgument(); if (notify_sync) { std::vector<std::string> guids; if (!db_->GetAutofillTable()->GetAutofillProfilesInTrash(&guids)) { NOTREACHED(); return; } for (std::vector<std::string>::const_iterator iter = guids.begin(); iter != guids.end(); ++iter) { // Send GUID-based notification. AutofillProfileChange change(AutofillProfileChange::REMOVE, *iter, NULL); NotificationService::current()->Notify( NotificationType::AUTOFILL_PROFILE_CHANGED, Source<WebDataService>(this), Details<AutofillProfileChange>(&change)); } // If we trashed any profiles they may have been merged, so send out // update notifications as well. if (!guids.empty()) { std::vector<AutofillProfile*> profiles; db_->GetAutofillTable()->GetAutofillProfiles(&profiles); for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin(); iter != profiles.end(); ++iter) { AutofillProfileChange change(AutofillProfileChange::UPDATE, (*iter)->guid(), *iter); NotificationService::current()->Notify( NotificationType::AUTOFILL_PROFILE_CHANGED, Source<WebDataService>(this), Details<AutofillProfileChange>(&change)); } STLDeleteElements(&profiles); } } if (!db_->GetAutofillTable()->EmptyAutofillProfilesTrash()) { NOTREACHED(); return; } ScheduleCommit(); } request->RequestComplete(); } void WebDataService::AddCreditCardImpl( GenericRequest<CreditCard>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { const CreditCard& credit_card = request->GetArgument(); if (!db_->GetAutofillTable()->AddCreditCard(credit_card)) { NOTREACHED(); return; } ScheduleCommit(); // Send GUID-based notification. AutofillCreditCardChange change(AutofillCreditCardChange::ADD, credit_card.guid(), &credit_card); NotificationService::current()->Notify( NotificationType::AUTOFILL_CREDIT_CARD_CHANGED, Source<WebDataService>(this), Details<AutofillCreditCardChange>(&change)); } request->RequestComplete(); } void WebDataService::UpdateCreditCardImpl( GenericRequest<CreditCard>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { const CreditCard& credit_card = request->GetArgument(); // It is currently valid to try to update a missing profile. We simply drop // the write and the caller will detect this on the next refresh. CreditCard* original_credit_card = NULL; if (!db_->GetAutofillTable()->GetCreditCard(credit_card.guid(), &original_credit_card)) { request->RequestComplete(); return; } scoped_ptr<CreditCard> scoped_credit_card(original_credit_card); if (!db_->GetAutofillTable()->UpdateCreditCard(credit_card)) { NOTREACHED(); return; } ScheduleCommit(); // Send GUID-based notification. AutofillCreditCardChange change(AutofillCreditCardChange::UPDATE, credit_card.guid(), &credit_card); NotificationService::current()->Notify( NotificationType::AUTOFILL_CREDIT_CARD_CHANGED, Source<WebDataService>(this), Details<AutofillCreditCardChange>(&change)); } request->RequestComplete(); } void WebDataService::RemoveCreditCardImpl( GenericRequest<std::string>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::string guid = request->GetArgument(); if (!db_->GetAutofillTable()->RemoveCreditCard(guid)) { NOTREACHED(); return; } ScheduleCommit(); // Send GUID-based notification. AutofillCreditCardChange change(AutofillCreditCardChange::REMOVE, guid, NULL); NotificationService::current()->Notify( NotificationType::AUTOFILL_CREDIT_CARD_CHANGED, Source<WebDataService>(this), Details<AutofillCreditCardChange>(&change)); } request->RequestComplete(); } void WebDataService::GetCreditCardsImpl(WebDataRequest* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::vector<CreditCard*> credit_cards; db_->GetAutofillTable()->GetCreditCards(&credit_cards); request->SetResult( new WDResult<std::vector<CreditCard*> >(AUTOFILL_CREDITCARDS_RESULT, credit_cards)); } request->RequestComplete(); } void WebDataService::RemoveAutofillProfilesAndCreditCardsModifiedBetweenImpl( GenericRequest2<Time, Time>* request) { InitializeDatabaseIfNecessary(); if (db_ && !request->IsCancelled()) { std::vector<std::string> profile_guids; std::vector<std::string> credit_card_guids; if (db_->GetAutofillTable()-> RemoveAutofillProfilesAndCreditCardsModifiedBetween( request->GetArgument1(), request->GetArgument2(), &profile_guids, &credit_card_guids)) { for (std::vector<std::string>::iterator iter = profile_guids.begin(); iter != profile_guids.end(); ++iter) { AutofillProfileChange change(AutofillProfileChange::REMOVE, *iter, NULL); NotificationService::current()->Notify( NotificationType::AUTOFILL_PROFILE_CHANGED, Source<WebDataService>(this), Details<AutofillProfileChange>(&change)); } for (std::vector<std::string>::iterator iter = credit_card_guids.begin(); iter != credit_card_guids.end(); ++iter) { AutofillCreditCardChange change(AutofillCreditCardChange::REMOVE, *iter, NULL); NotificationService::current()->Notify( NotificationType::AUTOFILL_CREDIT_CARD_CHANGED, Source<WebDataService>(this), Details<AutofillCreditCardChange>(&change)); } // Note: It is the caller's responsibility to post notifications for any // changes, e.g. by calling the Refresh() method of PersonalDataManager. ScheduleCommit(); } } request->RequestComplete(); } //////////////////////////////////////////////////////////////////////////////// // // WebDataRequest implementation. // //////////////////////////////////////////////////////////////////////////////// WebDataService::WebDataRequest::WebDataRequest(WebDataService* service, Handle handle, WebDataServiceConsumer* consumer) : service_(service), handle_(handle), canceled_(false), consumer_(consumer), result_(NULL) { message_loop_ = MessageLoop::current(); } WebDataService::WebDataRequest::~WebDataRequest() { delete result_; } WebDataService::Handle WebDataService::WebDataRequest::GetHandle() const { return handle_; } WebDataServiceConsumer* WebDataService::WebDataRequest::GetConsumer() const { return consumer_; } bool WebDataService::WebDataRequest::IsCancelled() const { return canceled_; } void WebDataService::WebDataRequest::Cancel() { canceled_ = true; consumer_ = NULL; } void WebDataService::WebDataRequest::SetResult(WDTypedResult* r) { result_ = r; } const WDTypedResult* WebDataService::WebDataRequest::GetResult() const { return result_; } void WebDataService::WebDataRequest::RequestComplete() { WebDataService* s = service_; Task* t = NewRunnableMethod(s, &WebDataService::RequestCompleted, handle_); message_loop_->PostTask(FROM_HERE, t); }