Add deletion to the activityLogPrivate API

chrome/browser/extensions/activity_log/fullstream_ui_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.
 
 #include "chrome/browser/extensions/activity_log/fullstream_ui_policy.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
@@ skipping 140 matching lines @@
   }
   if (!page_url.empty()) {
     where_str += where_next + "page_url LIKE ?";
     where_next = " AND ";
   }
   if (!arg_url.empty()) {
     where_str += where_next + "arg_url LIKE ?";
   }
   std::string query_str = base::StringPrintf(
       "SELECT extension_id,time,action_type,api_name,args,page_url,page_title,"
-      "arg_url,other FROM %s WHERE %s ORDER BY time DESC",
+      "arg_url,other FROM %s %s %s ORDER BY time DESC",
       kTableName,
+      where_str.empty() ? "" : "WHERE",
       where_str.c_str());
   sql::Statement query(db->GetUniqueStatement(query_str.c_str()));
   int i = -1;
   if (!extension_id.empty())
     query.BindString(++i, extension_id);
   if (!api_name.empty())
     query.BindString(++i, api_name);
   if (type != Action::ACTION_ANY)
     query.BindInt(++i, static_cast<int>(type));
   if (!page_url.empty())
@@ skipping 160 matching lines @@
     statement.BindString(0, restrict_urls[i].spec());
 
     if (!statement.Run()) {
       LOG(ERROR) << "Removing arg URL from database failed: "
                  << statement.GetSQLStatement();
       return;
     }
   }
 }
 
+void FullStreamUIPolicy::DoDeleteDatabase() {
+  sql::Connection* db = GetDatabaseConnection();
+  if (!db) {
+    LOG(ERROR) << "Unable to connect to database";
+    return;
+  }
+
+  queued_actions_.clear();
+
+  // Not wrapped in a transaction because the deletion should happen even if
+  // the vacuuming fails.
+  std::string sql_str = base::StringPrintf("DELETE FROM %s;", kTableName);
+  sql::Statement statement(db->GetCachedStatement(
+      sql::StatementID(SQL_FROM_HERE), sql_str.c_str()));
+  if (!statement.Run()) {
+    LOG(ERROR) << "Deleting the database failed: "
+               << statement.GetSQLStatement();
+    return;
+  }
+  statement.Clear();
+  statement.Assign(db->GetCachedStatement(sql::StatementID(SQL_FROM_HERE),
+                                          "VACUUM"));
+  if (!statement.Run()) {
+    LOG(ERROR) << "Vacuuming the database failed: "
+               << statement.GetSQLStatement();
+  }
+}
+
 void FullStreamUIPolicy::OnDatabaseFailure() {
   queued_actions_.clear();
 }
 
 void FullStreamUIPolicy::OnDatabaseClose() {
   delete this;
 }
 
 void FullStreamUIPolicy::Close() {
   // The policy object should have never been created if there's no DB thread.
@@ skipping 34 matching lines @@
                  api_name,
                  page_url,
                  arg_url),
       callback);
 }
 
 void FullStreamUIPolicy::RemoveURLs(const std::vector<GURL>& restrict_urls) {
   ScheduleAndForget(this, &FullStreamUIPolicy::DoRemoveURLs, restrict_urls);
 }
 
+void FullStreamUIPolicy::DeleteDatabase() {
+  ScheduleAndForget(this, &FullStreamUIPolicy::DoDeleteDatabase);
+}
+
 scoped_refptr<Action> FullStreamUIPolicy::ProcessArguments(
     scoped_refptr<Action> action) const {
   return action;
 }
 
 void FullStreamUIPolicy::ProcessAction(scoped_refptr<Action> action) {
   // TODO(mvrable): Right now this argument stripping updates the Action object
   // in place, which isn't good if there are other users of the object.  When
   // database writing is moved to policy class, the modifications should be
   // made locally.
   action = ProcessArguments(action);
   ScheduleAndForget(this, &FullStreamUIPolicy::QueueAction, action);
 }
 
 void FullStreamUIPolicy::QueueAction(scoped_refptr<Action> action) {
   if (activity_database()->is_db_valid()) {
     queued_actions_.push_back(action);
     activity_database()->AdviseFlush(queued_actions_.size());
   }
 }
 
 }  // namespace extensions