Handle TemplateURLService load failure better

chrome/browser/search_engines/template_url_service.h

 // Copyright (c) 2012 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.
 
 #ifndef CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_
 #define CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 94 matching lines @@
   // SaveDefaultSearchProviderToPrefs or set via policy.
   // Returns true if successful, false otherwise.
   // If the user or the policy has opted for no default search, this
   // returns true but default_provider is set to NULL.
   // |*is_managed| specifies whether the default is managed via policy.
   static bool LoadDefaultSearchProviderFromPrefs(
       PrefService* prefs,
       scoped_ptr<TemplateURLData>* default_provider_data,
       bool* is_managed);
 
-  // Saves enough of url to |prefs| so that it can be loaded from preferences on
-  // start up.
-  static void SaveDefaultSearchProviderToPrefs(const TemplateURL* url,
-                                               PrefService* prefs);
-
   // Generates a suitable keyword for the specified url, which must be valid.
   // This is guaranteed not to return an empty string, since TemplateURLs should
   // never have an empty keyword.
   static base::string16 GenerateKeyword(const GURL& url);
 
   // Removes any unnecessary characters from a user input keyword.
   // This removes the leading scheme, "www." and any trailing slash.
   static base::string16 CleanUserInputKeyword(const base::string16& keyword);
 
   // Returns the search url for t_url.  Returns an empty GURL if t_url has no
   // url().
   // NOTE: |t_url| is non-const in this version because of the need to access
   // t_url->profile().
   static GURL GenerateSearchURL(TemplateURL* t_url);
 
   // Just like GenerateSearchURL except that it takes SearchTermsData to supply
   // the data for some search terms, e.g. so this can be used on threads other
   // than the UI thread.  See the various TemplateURLRef::XXXUsingTermsData()
   // functions.
   static GURL GenerateSearchURLUsingTermsData(
       const TemplateURL* t_url,
       const SearchTermsData& search_terms_data);
 
+  // Saves enough of url to |prefs| so that it can be loaded from preferences on
+  // start up.
+  void SaveDefaultSearchProviderToPrefs(const TemplateURL* url,
+                                        PrefService* prefs) const;
+
   // Returns true if there is no TemplateURL that conflicts with the
   // keyword/url pair, or there is one but it can be replaced. If there is an
   // existing keyword that can be replaced and template_url_to_replace is
   // non-NULL, template_url_to_replace is set to the keyword to replace.
   //
   // url gives the url of the search query. The url is used to avoid generating
   // a TemplateURL for an existing TemplateURL that shares the same host.
   bool CanReplaceKeyword(const base::string16& keyword,
                          const GURL& url,
                          TemplateURL** template_url_to_replace);
@@ skipping 249 matching lines @@
                                            const base::string16& term);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceTest, TestManagedDefaultSearch);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceTest,
                            UpdateKeywordSearchTermsForURL);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceTest,
                            DontUpdateKeywordSearchForNonReplaceable);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceTest, ChangeGoogleBaseValue);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceTest, MergeDeletesUnusedProviders);
+  FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest, UniquifyKeyword);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
-                           CreateSyncDataFromTemplateURL);
-  FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
-                           CreateTemplateURLFromSyncData);
-  FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest, UniquifyKeyword);
+                           IsLocalTemplateURLBetter);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
                            ResolveSyncKeywordConflict);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest, PreSyncDeletes);
-  FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
-                           IsLocalTemplateURLBetter);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest, MergeInSyncTemplateURL);
 
+  friend class TemplateURLServiceSyncTest;
   friend class TemplateURLServiceTestUtilBase;
 
   typedef std::map<base::string16, TemplateURL*> KeywordToTemplateMap;
   typedef std::map<std::string, TemplateURL*> GUIDToTemplateMap;
 
   // Declaration of values to be used in an enumerated histogram to tally
   // changes to the default search provider from various entry points. In
   // particular, we use this to see what proportion of changes are from Sync
   // entry points, to help spot erroneous Sync activity.
   enum DefaultSearchChangeOrigin {
@@ skipping 35 matching lines @@
   // This does NOT notify the delegate or the database.
   //
   // This transfers ownership of the elements in |urls| to |this|, and may
   // delete some elements, so it's not safe for callers to access any elements
   // after calling; to reinforce this, this function clears |urls| on exit.
   void SetTemplateURLs(TemplateURLVector* urls);
 
   // Transitions to the loaded state.
   void ChangeToLoadedState();
 
+  // Called when we transition to the loaded state without having loaded the web
+  // database from disk.  This may be because of profile corruption, or because
+  // we're in a test.  Disables further attempts to access the web database and
+  // ensures we won't attempt to sync any changes, then copies
+  // |initial_default_search_provider_| in as the default search provider, so
+  // the TemplateURLService consistently reports the same default provider
+  // before and after the attempted load.
+  void OnFailedLoad();
+
   // Clears user preferences describing the default search engine.
   void ClearDefaultProviderFromPrefs();
 
   // Returns true if there is no TemplateURL that has a search url with the
   // specified host, or the only TemplateURLs matching the specified host can
   // be replaced.
   bool CanReplaceKeywordForHost(const std::string& host,
                                 TemplateURL** to_replace);
 
   // Returns true if the TemplateURL is replaceable. This doesn't look at the
@@ skipping 217 matching lines @@
   scoped_ptr<SearchHostToURLsMap> provider_map_;
 
   // Used to obtain the WebDataService.
   // When Load is invoked, if we haven't yet loaded, the WebDataService is
   // obtained from the Profile. This allows us to lazily access the database.
   Profile* profile_;
 
   // Whether the keywords have been loaded.
   bool loaded_;
 
-  // Did loading fail? This is only valid if loaded_ is true.
+  // Set by OnFailedLoad(); prevents writing to prefs or syncing.
   bool load_failed_;
 
   // If non-zero, we're waiting on a load.
   WebDataService::Handle load_handle_;
 
   // Service used to store entries.
   scoped_refptr<WebDataService> service_;
 
   // All visits that occurred before we finished loading. Once loaded
   // UpdateKeywordSearchTermsForURL is invoked for each element of the vector.
@@ skipping 55 matching lines @@
   base::CallbackList<void(void)> on_loaded_callbacks_;
 
   // Helper class to manage the default search engine. This will be NULL when
   // using the testing-specific constructor.
   scoped_ptr<DefaultSearchManager> default_search_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLService);
 };
 
 #endif  // CHROME_BROWSER_SEARCH_ENGINES_TEMPLATE_URL_SERVICE_H_