Update tests to check fields directly.

chrome/browser/extensions/activity_log/counting_policy.cc

 // Copyright 2013 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.
 
 // A policy for storing activity log data to a database that performs
 // aggregation to reduce the size of the database.  The database layout is
 // nearly the same as FullStreamUIPolicy, which stores a complete log, with a
 // few changes:
 //   - a "count" column is added to track how many log records were merged
 //     together into this row
@@ skipping 109 matching lines @@
     "DELETE FROM url_ids WHERE id NOT IN\n"
     "(SELECT page_url_x FROM activitylog_compressed\n"
     "    WHERE page_url_x IS NOT NULL\n"
     " UNION SELECT arg_url_x FROM activitylog_compressed\n"
     "    WHERE arg_url_x IS NOT NULL)";
 
 }  // namespace
 
 namespace extensions {
 
-// A specialized Action subclass which is used to represent an action read from
-// the database with a corresponding count.
-class CountedAction : public Action {
- public:
-  CountedAction(const std::string& extension_id,
-                const base::Time& time,
-                const ActionType action_type,
-                const std::string& api_name)
-      : Action(extension_id, time, action_type, api_name),
-        count_(0) {
-  }
-
-  // Number of merged records for this action.
-  int count() const { return count_; }
-  void set_count(int count) { count_ = count; }
-
-  virtual std::string PrintForDebug() const OVERRIDE;
-
- protected:
-  virtual ~CountedAction() {}
-
- private:
-  int count_;
-};
-
-std::string CountedAction::PrintForDebug() const {
-  return base::StringPrintf(
-      "%s COUNT=%d", Action::PrintForDebug().c_str(), count());
-}
-
 const char* CountingPolicy::kTableName = "activitylog_compressed";
 const char* CountingPolicy::kReadViewName = "activitylog_uncompressed";
 
 CountingPolicy::CountingPolicy(Profile* profile)
     : ActivityLogDatabasePolicy(
           profile,
           base::FilePath(chrome::kExtensionActivityLogFilename)),
       string_table_("string_ids"),
       url_table_("url_ids"),
       retention_time_(base::TimeDelta::FromHours(60)) {
@@ skipping 284 matching lines @@
     query.BindString(++i, api_name);
   if (type != Action::ACTION_ANY)
     query.BindInt(++i, static_cast<int>(type));
   if (!page_url.empty())
     query.BindString(++i, page_url + "%");
   if (!arg_url.empty())
     query.BindString(++i, arg_url + "%");
 
   // Execute the query and get results.
   while (query.is_valid() && query.Step()) {
-    scoped_refptr<CountedAction> action =
-        new CountedAction(query.ColumnString(0),
+    scoped_refptr<Action> action =
+        new Action(query.ColumnString(0),
                    base::Time::FromInternalValue(query.ColumnInt64(1)),
                    static_cast<Action::ActionType>(query.ColumnInt(2)),
                    query.ColumnString(3));
 
     if (query.ColumnType(4) != sql::COLUMN_TYPE_NULL) {
       scoped_ptr<Value> parsed_value(
           base::JSONReader::Read(query.ColumnString(4)));
       if (parsed_value && parsed_value->IsType(Value::TYPE_LIST)) {
         action->set_args(
             make_scoped_ptr(static_cast<ListValue*>(parsed_value.release())));
@@ skipping 43 matching lines @@
       "FROM %s WHERE extension_id=? AND time>? AND time<=? "
       "ORDER BY time DESC",
       kReadViewName);
   sql::Statement query(db->GetCachedStatement(SQL_FROM_HERE,
                                               query_str.c_str()));
   query.BindString(0, extension_id);
   query.BindInt64(1, early_bound);
   query.BindInt64(2, late_bound);
 
   while (query.is_valid() && query.Step()) {
-    scoped_refptr<CountedAction> action =
-        new CountedAction(extension_id,
-                          base::Time::FromInternalValue(query.ColumnInt64(0)),
-                          static_cast<Action::ActionType>(query.ColumnInt(1)),
-                          query.ColumnString(2));
+    scoped_refptr<Action> action =
+        new Action(extension_id,
+                   base::Time::FromInternalValue(query.ColumnInt64(0)),
+                   static_cast<Action::ActionType>(query.ColumnInt(1)),
+                   query.ColumnString(2));
 
     if (query.ColumnType(3) != sql::COLUMN_TYPE_NULL) {
       scoped_ptr<Value> parsed_value(
           base::JSONReader::Read(query.ColumnString(3)));
       if (parsed_value && parsed_value->IsType(Value::TYPE_LIST)) {
         action->set_args(
             make_scoped_ptr(static_cast<ListValue*>(parsed_value.release())));
       } else {
         LOG(WARNING) << "Unable to parse args: '" << query.ColumnString(3)
                      << "'";
@@ skipping 176 matching lines @@
   return true;
 }
 
 void CountingPolicy::Close() {
   // The policy object should have never been created if there's no DB thread.
   DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::DB));
   ScheduleAndForget(activity_database(), &ActivityDatabase::Close);
 }
 
 }  // namespace extensions