Introducing the activityLogPrivate.deleteActivities() API call.

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 500 matching lines @@
             static_cast<base::DictionaryValue*>(parsed_value.release())));
       }
     }
     action->set_count(query.ColumnInt(9));
     actions->push_back(action);
   }
 
   return actions.Pass();
 }
 
+void CountingPolicy::DoRemoveActions(const std::vector<int64>& action_ids) {
+  if (action_ids.empty())
+    return;
+
+  sql::Connection* db = GetDatabaseConnection();
+  if (!db) {
+    LOG(ERROR) << "Unable to connect to database";
+    return;
+  }
+
+  // Flush data first so the activity removal affects queued-up data as well.
+  activity_database()->AdviseFlush(ActivityDatabase::kFlushImmediately);
+
+  sql::Transaction transaction(db);
+  if (!transaction.Begin())
+    return;
+
+  for (size_t i = 0; i < action_ids.size(); i++) {
+    std::string query_str =

[mvrable, 2014/02/12 18:38:55]

query_str can be moved outside the loop since it doesn't change.  In fact, I
think you can even move getting the statement outside the loop and call
query.Reset() after each iteration.

Minor nit: maybe rename from query since that implies a SELECT statement to me. 
Perhaps statement, or delete_stmt, or something similar?

[pmarch, 2014/02/12 19:03:23]

Done.

+        base::StringPrintf("DELETE FROM %s WHERE rowid = ?", kTableName);
+    sql::Statement query(db->GetCachedStatement(sql::StatementID(SQL_FROM_HERE),
+                                                query_str.c_str()));
+    query.BindInt64(0, action_ids[i]);
+    if (!query.Run()) {
+      LOG(ERROR) << "Removing activities from database failed: "
+                 << query.GetSQLStatement();
+      break;
+    }
+  }
+
+  CleanStringTables(db);
+
+  if (!transaction.Commit()) {
+    LOG(ERROR) << "Removing activities from database failed";
+  }
+}
+
 void CountingPolicy::DoRemoveURLs(const std::vector<GURL>& restrict_urls) {
   sql::Connection* db = GetDatabaseConnection();
   if (!db) {
     LOG(ERROR) << "Unable to connect to database";
     return;
   }
 
   // Flush data first so the URL clearing affects queued-up data as well.
   activity_database()->AdviseFlush(ActivityDatabase::kFlushImmediately);
 
@@ skipping 156 matching lines @@
                  base::Unretained(this),
                  extension_id,
                  type,
                  api_name,
                  page_url,
                  arg_url,
                  days_ago),
       callback);
 }
 
+void CountingPolicy::RemoveActions(const std::vector<int64>& action_ids) {
+  ScheduleAndForget(this, &CountingPolicy::DoRemoveActions, action_ids);
+}
+
 void CountingPolicy::RemoveURLs(const std::vector<GURL>& restrict_urls) {
   ScheduleAndForget(this, &CountingPolicy::DoRemoveURLs, restrict_urls);
 }
 
 void CountingPolicy::RemoveExtensionData(const std::string& extension_id) {
   ScheduleAndForget(this, &CountingPolicy::DoRemoveExtensionData, extension_id);
 }
 
 void CountingPolicy::DeleteDatabase() {
   ScheduleAndForget(this, &CountingPolicy::DoDeleteDatabase);
@@ skipping 40 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