Some C++11 cleanup of history types.

components/history/core/browser/history_types.h

 // Copyright 2014 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 COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_TYPES_H_
 #define COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_TYPES_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 60 matching lines @@
  public:
   VisitRow();
   VisitRow(URLID arg_url_id,
            base::Time arg_visit_time,
            VisitID arg_referring_visit,
            ui::PageTransition arg_transition,
            SegmentID arg_segment_id);
   ~VisitRow();
 
   // ID of this row (visit ID, used a a referrer for other visits).
-  VisitID visit_id;
+  VisitID visit_id = 0;
 
   // Row ID into the URL table of the URL that this page is.
-  URLID url_id;
+  URLID url_id = 0;
 
   base::Time visit_time;
 
   // Indicates another visit that was the referring page for this one.
   // 0 indicates no referrer.
-  VisitID referring_visit;
+  VisitID referring_visit = 0;
 
   // A combination of bits from PageTransition.
-  ui::PageTransition transition;
+  ui::PageTransition transition = ui::PAGE_TRANSITION_LINK;
 
   // The segment id (see visitsegment_database.*).
   // If 0, the segment id is null in the table.
-  SegmentID segment_id;
+  SegmentID segment_id = 0;
 
   // Record how much time a user has this visit starting from the user
   // opened this visit to the user closed or ended this visit.
   // This includes both active and inactive time as long as
   // the visit was present.
   base::TimeDelta visit_duration;
 
   // Compares two visits based on dates, for sorting.
-  bool operator<(const VisitRow& other) {
+  bool operator<(const VisitRow& other) const {
     return visit_time < other.visit_time;
   }
 
   // We allow the implicit copy constuctor and operator=.
 };
 
 // We pass around vectors of visits a lot
 typedef std::vector<VisitRow> VisitVector;
 
 // The basic information associated with a visit (timestamp, type of visit),
 // used by HistoryBackend::AddVisits() to create new visits for a URL.
 typedef std::pair<base::Time, ui::PageTransition> VisitInfo;
 
 // PageVisit ------------------------------------------------------------------
 
 // Represents a simplified version of a visit for external users. Normally,
 // views are only interested in the time, and not the other information
 // associated with a VisitRow.
 struct PageVisit {
-  URLID page_id;
+  URLID page_id = 0;
   base::Time visit_time;
 };
 
 // QueryResults ----------------------------------------------------------------
 
 // Encapsulates the results of a history query. It supports an ordered list of
 // URLResult objects, plus an efficient way of looking up the index of each time
 // a given URL appears in those results.
 class QueryResults {
  public:
@@ skipping 61 matching lines @@
   void DeleteURL(const GURL& url);
 
   // Deletes the given range of items in the result set.
   void DeleteRange(size_t begin, size_t end);
 
  private:
   // Maps the given URL to a list of indices into results_ which identify each
   // time an entry with that URL appears. Normally, each URL will have one or
   // very few indices after it, so we optimize this to use statically allocated
   // memory when possible.
-  typedef std::map<GURL, base::StackVector<size_t, 4> > URLToResultIndices;
+  typedef std::map<GURL, base::StackVector<size_t, 4>> URLToResultIndices;
 
   // Inserts an entry into the |url_to_results_| map saying that the given URL
   // is at the given index in the results_.
   void AddURLUsageAtIndex(const GURL& url, size_t index);
 
   // Adds |delta| to each index in url_to_results_ in the range [begin,end]
   // (this is inclusive). This is used when inserting or deleting.
   void AdjustResultMap(size_t begin, size_t end, ptrdiff_t delta);
 
   base::Time first_time_searched_;
@@ skipping 25 matching lines @@
   // text query is empty, this will return the most recent visit within the
   // time range.
   base::Time begin_time;
   base::Time end_time;
 
   // Sets the query time to the last |days_ago| days to the present time.
   void SetRecentDayRange(int days_ago);
 
   // The maximum number of results to return. The results will be sorted with
   // the most recent first, so older results may not be returned if there is not
-  // enough room. When 0, this will return everything (the default).
-  int max_count;
+  // enough room. When 0, this will return everything.
+  int max_count = 0;
 
   enum DuplicateHandling {
     // Omit visits for which there is a more recent visit to the same URL.
     // Each URL in the results will appear only once.
     REMOVE_ALL_DUPLICATES,
 
     // Omit visits for which there is a more recent visit to the same URL on
     // the same day. Each URL will appear no more than once per day, where the
     // day is defined by the local timezone.
     REMOVE_DUPLICATES_PER_DAY,
 
     // Return all visits without deduping.
     KEEP_ALL_DUPLICATES
   };
 
   // Allows the caller to specify how duplicate URLs in the result set should
-  // be handled. The default is REMOVE_DUPLICATES.
-  DuplicateHandling duplicate_policy;
+  // be handled.
+  DuplicateHandling duplicate_policy = REMOVE_ALL_DUPLICATES;
 
   // Allows the caller to specify the matching algorithm for text queries.
-  query_parser::MatchingAlgorithm matching_algorithm;
+  query_parser::MatchingAlgorithm matching_algorithm =
+      query_parser::MatchingAlgorithm::DEFAULT;
 
   // Helpers to get the effective parameters values, since a value of 0 means
   // "unspecified".
   int EffectiveMaxCount() const;
   int64_t EffectiveBeginTime() const;
   int64_t EffectiveEndTime() const;
 };
 
 // QueryURLResult -------------------------------------------------------------
 
 // QueryURLResult encapsulates the result of a call to HistoryBackend::QueryURL.
 struct QueryURLResult {
   QueryURLResult();
   ~QueryURLResult();
 
   // Indicates whether the call to HistoryBackend::QueryURL was successfull
   // or not. If false, then both |row| and |visits| fields are undefined.
-  bool success;
+  bool success = false;
   URLRow row;
   VisitVector visits;
 };
 
 // VisibleVisitCountToHostResult ----------------------------------------------
 
 // VisibleVisitCountToHostResult encapsulates the result of a call to
 // HistoryBackend::GetVisibleVisitCountToHost.
 struct VisibleVisitCountToHostResult {
   // Indicates whether the call to HistoryBackend::GetVisibleVisitCountToHost
   // was successful or not. If false, then both |count| and |first_visit| are
   // undefined.
-  bool success;
-  int count;
+  bool success = false;
+  int count = 0;
   base::Time first_visit;
 };
 
 // MostVisitedURL --------------------------------------------------------------
 
 // Holds the per-URL information of the most visited query.
 struct MostVisitedURL {
   MostVisitedURL();
-  MostVisitedURL(const GURL& url, const base::string16& title);
   MostVisitedURL(const GURL& url,
                  const base::string16& title,
-                 const base::Time& last_forced_time);
+                 base::Time last_forced_time = base::Time());
   MostVisitedURL(const MostVisitedURL& other);
+  MostVisitedURL(MostVisitedURL&& other) noexcept;
   ~MostVisitedURL();
 
   GURL url;
   base::string16 title;
 
   // If this is a URL for which we want to force a thumbnail, records the last
   // time it was forced so we can evict it when more recent URLs are requested.
   // If it's not a forced thumbnail, keep a time of 0.
   base::Time last_forced_time;
 
   RedirectList redirects;
 
+  MostVisitedURL& operator=(const MostVisitedURL&);
+
   bool operator==(const MostVisitedURL& other) const {
     return url == other.url;
   }
 };
 
 // FilteredURL -----------------------------------------------------------------
 
 // Holds the per-URL information of the filterd url query.
 struct FilteredURL {
   struct ExtendedInfo {
     ExtendedInfo();
     // The absolute number of visits.
-    unsigned int total_visits;
+    unsigned int total_visits = 0;
     // The number of visits, as seen by the Most Visited NTP pane.
-    unsigned int visits;
+    unsigned int visits = 0;
     // The total number of seconds that the page was open.
-    int64_t duration_opened;
+    int64_t duration_opened = 0;
     // The time when the page was last visited.
     base::Time last_visit_time;
   };
 
   FilteredURL();
   explicit FilteredURL(const PageUsageData& data);
+  FilteredURL(FilteredURL&& other) noexcept;
   ~FilteredURL();
 
   GURL url;
   base::string16 title;
-  double score;
+  double score = 0.0;
   ExtendedInfo extended_info;
 };
 
 // Navigation -----------------------------------------------------------------
 
 // Marshalling structure for AddPage.
 struct HistoryAddPageArgs {
   // The default constructor is equivalent to:
   //
   //   HistoryAddPageArgs(
@@ skipping 58 matching lines @@
 struct TopSitesDelta {
   TopSitesDelta();
   TopSitesDelta(const TopSitesDelta& other);
   ~TopSitesDelta();
 
   MostVisitedURLList deleted;
   MostVisitedURLWithRankList added;
   MostVisitedURLWithRankList moved;
 };
 
-typedef std::map<GURL, scoped_refptr<base::RefCountedBytes> > URLToThumbnailMap;
+typedef std::map<GURL, scoped_refptr<base::RefCountedBytes>> URLToThumbnailMap;
 
 // Used when migrating most visited thumbnails out of history and into topsites.
 struct ThumbnailMigration {
   ThumbnailMigration();
   ~ThumbnailMigration();
 
   MostVisitedURLList most_visited;
   URLToThumbnailMap url_to_thumbnail_map;
 };
 
@@ skipping 21 matching lines @@
 // URL under that origin.
 typedef std::map<GURL, std::pair<int, base::Time>> OriginCountAndLastVisitMap;
 
 // Statistics -----------------------------------------------------------------
 
 // HistoryCountResult encapsulates the result of a call to
 // HistoryBackend::GetHistoryCount.
 struct HistoryCountResult {
   // Indicates whether the call to HistoryBackend::GetHistoryCount was
   // successful or not. If false, then |count| is undefined.
-  bool success;
-  int count;
+  bool success = false;
+  int count = 0;
 };
 
 // Favicons -------------------------------------------------------------------
 
 // Used for the mapping between the page and icon.
 struct IconMapping {
   IconMapping();
+  IconMapping(const IconMapping&);
+  IconMapping(IconMapping&&) noexcept;
   ~IconMapping();
 
+  IconMapping& operator=(const IconMapping&);
+
   // The unique id of the mapping.
-  IconMappingID mapping_id;
+  IconMappingID mapping_id = 0;
 
   // The url of a web page.
   GURL page_url;
 
   // The unique id of the icon.
-  favicon_base::FaviconID icon_id;
+  favicon_base::FaviconID icon_id = 0;
 
   // The url of the icon.
   GURL icon_url;
 
   // The type of icon.
-  favicon_base::IconType icon_type;
+  favicon_base::IconType icon_type = favicon_base::INVALID_ICON;
 };
 
 // Defines a favicon bitmap and its associated pixel size.
 struct FaviconBitmapIDSize {
   FaviconBitmapIDSize();
   ~FaviconBitmapIDSize();
 
   // The unique id of the favicon bitmap.
-  FaviconBitmapID bitmap_id;
+  FaviconBitmapID bitmap_id = 0;
 
   // The pixel dimensions of the associated bitmap.
   gfx::Size pixel_size;
 };
 
 // Defines a favicon bitmap stored in the history backend.
 struct FaviconBitmap {
   FaviconBitmap();
   FaviconBitmap(const FaviconBitmap& other);
   ~FaviconBitmap();
 
   // The unique id of the bitmap.
-  FaviconBitmapID bitmap_id;
+  FaviconBitmapID bitmap_id = 0;
 
   // The id of the favicon to which the bitmap belongs to.
-  favicon_base::FaviconID icon_id;
+  favicon_base::FaviconID icon_id = 0;
 
   // Time at which |bitmap_data| was last updated.
   base::Time last_updated;
 
   // Time at which |bitmap_data| was last requested.
   base::Time last_requested;
 
   // The bits of the bitmap.
   scoped_refptr<base::RefCountedMemory> bitmap_data;
 
@@ skipping 11 matching lines @@
   void SetTimeRangeForOneDay(base::Time time);
 
   std::set<GURL> urls;
   base::Time begin_time;
   base::Time end_time;
 };
 
 }  // namespace history
 
 #endif  // COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_TYPES_H_