Move implementation from header to source.

chrome/browser/autocomplete/autocomplete.h

 // Copyright (c) 2010 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_AUTOCOMPLETE_AUTOCOMPLETE_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 155 matching lines @@
   enum Type {
     INVALID,        // Empty input
     UNKNOWN,        // Valid input whose type cannot be determined
     REQUESTED_URL,  // Input autodetected as UNKNOWN, which the user wants to
                     // treat as an URL by specifying a desired_tld
     URL,            // Input autodetected as a URL
     QUERY,          // Input autodetected as a query
     FORCED_QUERY,   // Input forced to be a query by an initial '?'
   };
 
-  AutocompleteInput()
-      : type_(INVALID),
-        prevent_inline_autocomplete_(false),
-        prefer_keyword_(false),
-        synchronous_only_(false) {
-  }
-
+  AutocompleteInput();
   AutocompleteInput(const std::wstring& text,
                     const std::wstring& desired_tld,
                     bool prevent_inline_autocomplete,
                     bool prefer_keyword,
                     bool synchronous_only);
+  ~AutocompleteInput();
 
   // Converts |type| to a string representation.  Used in logging.
   static std::string TypeToString(Type type);
 
   // Parses |text| and returns the type of input this will be interpreted as.
   // The components of the input are stored in the output parameter |parts|, if
   // it is non-NULL.
   static Type Parse(const std::wstring& text,
                     const std::wstring& desired_tld,
                     url_parse::Parsed* parts,
@@ skipping 142 matching lines @@
     OPEN_HISTORY_PAGE,       // A synthetic result that opens the history page
                              // to search for the input.
     NUM_TYPES,
   };
 
   AutocompleteMatch();
   AutocompleteMatch(AutocompleteProvider* provider,
                     int relevance,
                     bool deletable,
                     Type type);
+  ~AutocompleteMatch();
 
   // Converts |type| to a string representation.  Used in logging.
   static std::string TypeToString(Type type);
 
   // Converts |type| to a resource identifier for the appropriate icon for this
   // type.
   static int TypeToIcon(Type type);
 
   // Comparison function for determining when one match is better than another.
   static bool MoreRelevant(const AutocompleteMatch& elem1,
@@ skipping 124 matching lines @@
     // queries.  Do not call this for a synchronous query.
     //
     // NOTE: There's no parameter to tell the listener _which_ provider is
     // calling it.  Because the AutocompleteController (the typical listener)
     // doesn't cache the providers' individual matches locally, it has to get
     // them all again when this is called anyway, so such a parameter wouldn't
     // actually be useful.
     virtual void OnProviderUpdate(bool updated_matches) = 0;
 
    protected:
-    virtual ~ACProviderListener() {}
+    virtual ~ACProviderListener();
   };
 
   AutocompleteProvider(ACProviderListener* listener,
                        Profile* profile,
-                       const char* name)
-      : profile_(profile),
-        listener_(listener),
-        done_(true),
-        name_(name) {
-  }
+                       const char* name);
 
   // Invoked when the profile changes.
   // NOTE: Do not access any previous Profile* at this point as it may have
   // already been deleted.
   void SetProfile(Profile* profile);
 
   // Called to start an autocomplete query.  The provider is responsible for
   // tracking its matches for this query and whether it is done processing the
   // query.  When new matches are available or the provider finishes, it
   // calls the controller's OnProviderUpdate() method.  The controller can then
   // get the new matches using the provider's accessors.
   // Exception: Matches available immediately after starting the query (that
   // is, synchronously) do not cause any notifications to be sent.  The
   // controller is expected to check for these without prompting (since
   // otherwise, starting each provider running would result in a flurry of
   // notifications).
   //
   // Once Stop() has been called, no more notifications should be sent.
   //
   // |minimal_changes| is an optimization that lets the provider do less work
   // when the |input|'s text hasn't changed.  See the body of
   // AutocompletePopupModel::StartAutocomplete().
   virtual void Start(const AutocompleteInput& input,
                      bool minimal_changes) = 0;
 
   // Called when a provider must not make any more callbacks for the current
   // query. This will be called regardless of whether the provider is already
   // done.
-  virtual void Stop() {
-    done_ = true;
-  }
+  virtual void Stop();
 
   // Returns the set of matches for the current query.
   const ACMatches& matches() const { return matches_; }
 
   // Returns whether the provider is done processing the query.
   bool done() const { return done_; }
 
   // Returns the name of this provider.
   const char* name() const { return name_; }
 
   // Called to delete a match and the backing data that produced it.  This
   // match should not appear again in this or future queries.  This can only be
   // called for matches the provider marks as deletable.  This should only be
   // called when no query is running.
   // NOTE: Remember to call OnProviderUpdate() if matches_ is updated.
-  virtual void DeleteMatch(const AutocompleteMatch& match) {}
+  virtual void DeleteMatch(const AutocompleteMatch& match);
 
   // A suggested upper bound for how many matches a provider should return.
   // TODO(pkasting): http://b/1111299 , http://b/933133 This should go away once
   // we have good relevance heuristics; the controller should handle all
   // culling.
   static const size_t kMaxMatches;
 
  protected:
   friend class base::RefCountedThreadSafe<AutocompleteProvider>;
 
@@ skipping 328 matching lines @@
   AutocompleteInput::Type input_type;
   // Selected index (if selected) or -1 (AutocompletePopupModel::kNoMatch).
   size_t selected_index;
   // Inline autocompleted length (if displayed).
   size_t inline_autocompleted_length;
   // Result set.
   const AutocompleteResult& result;
 };
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_H_