Revert of Handle TemplateURLService load failure better, and make some test correctness fixes that will be ne…

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,
+                           CreateSyncDataFromTemplateURL);
+  FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
+                           CreateTemplateURLFromSyncData);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest, UniquifyKeyword);
   FRIEND_TEST_ALL_PREFIXES(TemplateURLServiceSyncTest,
-                           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 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
@@ skipping 129 matching lines @@
   // cannot add the provided argument, it will delete it and return false.
   // Caller is responsible for notifying observers if this function returns
   // true.
   bool AddNoNotify(TemplateURL* template_url, bool newly_adding);
 
   // Removes the keyword from the model. This deletes the supplied TemplateURL.
   // This fails if the supplied template_url is the default search provider.
   // Caller is responsible for notifying observers.
   void RemoveNoNotify(TemplateURL* template_url);
 
-  // Like ResetTemplateURL(), but instead of notifying observers, returns
-  // whether anything has changed.
-  bool ResetTemplateURLNoNotify(TemplateURL* url,
-                                const base::string16& title,
-                                const base::string16& keyword,
-                                const std::string& search_url);
-
   // Notify the observers that the model has changed.  This is done only if the
   // model is loaded.
   void NotifyObservers();
 
   // Removes from the vector any template URL that was created because of
   // policy.  These TemplateURLs are freed and removed from the database.
   // Sets default_search_provider to NULL if it was one of them, unless it is
   // the same as the current default from preferences and it is managed.
   void RemoveProvidersCreatedByPolicy(
       TemplateURLVector* template_urls,
@@ skipping 125 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_;
 
-  // Set when the web data service fails to load properly.  This prevents
-  // further communication with sync or writing to prefs, so we don't persist
-  // inconsistent state data anywhere.
+  // Did loading fail? This is only valid if loaded_ is true.
   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_