Add functions to clean URLs from the activity log

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 260 matching lines @@
         LOG(WARNING) << "Unable to parse other: '" << query.ColumnString(7)
                      << "'";
       }
     }
 
     actions->push_back(action);
   }
   return actions.Pass();
 }
 
+void FullStreamUIPolicy::DoRemoveURLs(const std::vector<GURL>& restrict_urls) {
+  sql::Connection* db = GetDatabaseConnection();
+  if (!db) {
+    LOG(ERROR) << "Unable to connect to database";
+    return;
+  }
+
+  // Make sure any queued in memory are sent to the database before cleaning.
+  activity_database()->AdviseFlush(ActivityDatabase::kFlushImmediately);
+
+  // If no restrictions then then all URLs need to be removed.
+  if (restrict_urls.empty()) {
+    sql::Statement statement;
+    std::string sql_str = base::StringPrintf(
+        "UPDATE %s SET page_url=NULL,page_title=NULL,arg_url=NULL",
+        kTableName);
+    statement.Assign(db->GetCachedStatement(
+        sql::StatementID(SQL_FROM_HERE), sql_str.c_str()));
+
+    if (!statement.Run()) {
+      LOG(ERROR) << "Removing URLs from database failed: "
+                 << statement.GetSQLStatement();
+    }
+    return;

[felt, 2013/08/27 23:16:55]

is this return in the wrong block?

[karenlees, 2013/08/27 23:26:55]

No, it was always supposed to return here as there is nothing more to do when
clearing all CLs (in the counting policy there is, so there isn't a return
here). As it returned here there was no point putting a return after the
LOG(ERROR) as it returned anyway.  

+  }
+
+  // If URLs are specified then restrict to only those URLs.
+  for (size_t i = 0; i < restrict_urls.size(); ++i) {
+    if (!restrict_urls[i].is_valid()) {
+      continue;
+    }
+
+    // Remove any matching page url info.
+    sql::Statement statement;
+    std::string sql_str = base::StringPrintf(
+      "UPDATE %s SET page_url=NULL,page_title=NULL WHERE page_url=?",
+      kTableName);
+    statement.Assign(db->GetCachedStatement(
+        sql::StatementID(SQL_FROM_HERE), sql_str.c_str()));
+    statement.BindString(0, restrict_urls[i].spec());
+
+    if (!statement.Run()) {
+      LOG(ERROR) << "Removing page URL from database failed: "
+                 << statement.GetSQLStatement();
+      return;
+    }
+
+    // Remove any matching arg urls.
+    sql_str = base::StringPrintf("UPDATE %s SET arg_url=NULL WHERE arg_url=?",
+                                 kTableName);
+    statement.Assign(db->GetCachedStatement(
+        sql::StatementID(SQL_FROM_HERE), sql_str.c_str()));
+    statement.BindString(0, restrict_urls[i].spec());
+
+    if (!statement.Run()) {
+      LOG(ERROR) << "Removing arg URL from database failed: "
+                 << statement.GetSQLStatement();
+      return;
+    }
+  }
+}
+
 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 30 matching lines @@
       base::Bind(&FullStreamUIPolicy::DoReadFilteredData,
                  base::Unretained(this),
                  extension_id,
                  type,
                  api_name,
                  page_url,
                  arg_url),
       callback);
 }
 
+void FullStreamUIPolicy::RemoveURLs(const std::vector<GURL>& restrict_urls) {
+  ScheduleAndForget(this, &FullStreamUIPolicy::DoRemoveURLs, restrict_urls);
+}
+
 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