Extension activity log database refactoring (step 3)

chrome/browser/extensions/activity_log/activity_database.cc

 // 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.
 
 #include <string>
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "chrome/browser/extensions/activity_log/activity_database.h"
 #include "chrome/browser/extensions/activity_log/fullstream_ui_policy.h"
 #include "chrome/common/chrome_switches.h"
 #include "sql/error_delegate_util.h"
 #include "sql/transaction.h"
 #include "third_party/sqlite/sqlite3.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif
 
 using content::BrowserThread;
 
-namespace {
-
-bool SortActionsByTime(const scoped_refptr<extensions::Action> a,
-                       const scoped_refptr<extensions::Action> b) {
-  return a->time() > b->time();
-}
-
-}  // namespace
-
 namespace extensions {
 
 ActivityDatabase::ActivityDatabase(ActivityDatabase::Delegate* delegate)
     : delegate_(delegate),
       testing_clock_(NULL),
       valid_db_(false),
       already_closed_(false),
       did_init_(false) {
   // We don't batch commits when in testing mode.
   batch_mode_ = !(CommandLine::ForCurrentProcess()->
@@ skipping 109 matching lines @@
       late_bound = base::Time::Max().ToInternalValue();
   } else {
       base::Time early_time = morning_midnight -
           base::TimeDelta::FromDays(days_ago);
       base::Time late_time = morning_midnight -
           base::TimeDelta::FromDays(days_ago-1);
       early_bound = early_time.ToInternalValue();
       late_bound = late_time.ToInternalValue();
   }
   std::string query_str = base::StringPrintf(
-      "SELECT time, action_type, api_name, args, page_url, arg_url, other "
-      "FROM %s WHERE extension_id=? AND time>? AND time<=?",
+      "SELECT time, action_type, api_name, args, page_url, page_title, "
+      "arg_url, other "
+      "FROM %s WHERE extension_id=? AND time>? AND time<=? "
+      "ORDER BY time DESC",
       FullStreamUIPolicy::kTableName);
   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_ptr<Value> raw_value(base::JSONReader::Read(query.ColumnString(3)));
-    scoped_ptr<ListValue> args;
-    if (raw_value && raw_value->IsType(Value::TYPE_LIST)) {
-      args.reset(static_cast<ListValue*>(raw_value.release()));
-    } else {
-      args.reset(new ListValue());
+    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)
+                     << "'";
+      }
     }
 
     GURL page_url(query.ColumnString(4));
-    GURL arg_url(query.ColumnString(5));
+    action->set_page_url(page_url);
 
-    raw_value.reset(base::JSONReader::Read(query.ColumnString(6)));
-    scoped_ptr<DictionaryValue> other;
-    if (raw_value && raw_value->IsType(Value::TYPE_DICTIONARY)) {
-      other.reset(static_cast<DictionaryValue*>(raw_value.release()));
-    } else {
-      other.reset(new DictionaryValue());
+    action->set_page_title(query.ColumnString(5));
+
+    GURL arg_url(query.ColumnString(6));
+    action->set_arg_url(arg_url);
+
+    if (query.ColumnType(7) != sql::COLUMN_TYPE_NULL) {
+      scoped_ptr<Value> parsed_value(
+          base::JSONReader::Read(query.ColumnString(7)));
+      if (parsed_value && parsed_value->IsType(Value::TYPE_DICTIONARY)) {
+        action->set_other(make_scoped_ptr(
+            static_cast<DictionaryValue*>(parsed_value.release())));
+      } else {
+        LOG(WARNING) << "Unable to parse other: '" << query.ColumnString(7)
+                     << "'";
+      }
     }
 
-    scoped_refptr<WatchdogAction> action =
-        new WatchdogAction(extension_id,
-                           base::Time::FromInternalValue(query.ColumnInt64(0)),
-                           static_cast<Action::ActionType>(query.ColumnInt(1)),
-                           query.ColumnString(2),
-                           args.Pass(),
-                           page_url,
-                           arg_url,
-                           other.Pass());
     actions->push_back(action);
   }
-  // Sort by time (from newest to oldest).
-  std::sort(actions->begin(), actions->end(), SortActionsByTime);
   return actions.Pass();
 }
 
 void ActivityDatabase::Close() {
   timer_.Stop();
   if (!already_closed_) {
     RecordBatchedActions();
     db_.reset_error_callback();
   }
   valid_db_ = false;
@@ skipping 76 matching lines @@
              field_types[i]);
         if (!db->Execute(table_updater.c_str()))
           return false;
       }
     }
   }
   return true;
 }
 
 }  // namespace extensions