New architecture of the activity logging: Policies for summarization (and compression)

chrome/browser/extensions/activity_log/fullstream_ui_policy.cc

Index: chrome/browser/extensions/activity_log/fullstream_ui_policy.cc
diff --git a/chrome/browser/extensions/activity_log/fullstream_ui_policy.cc b/chrome/browser/extensions/activity_log/fullstream_ui_policy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3e680cc51c05c64e585be1a6624f2b0c38d7c436
--- /dev/null
+++ b/chrome/browser/extensions/activity_log/fullstream_ui_policy.cc
@@ -0,0 +1,246 @@
+// 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 "base/files/file_path.h"
+#include "base/json/json_string_value_serializer.h"
+#include "base/logging.h"
+#include "base/string16.h"
+#include "chrome/browser/extensions/activity_log/activity_database.h"
+#include "chrome/browser/extensions/activity_log/api_actions.h"
+#include "chrome/browser/extensions/activity_log/blocked_actions.h"
+#include "chrome/browser/extensions/activity_log/dom_actions.h"
+#include "chrome/browser/extensions/activity_log/fullstream_ui_policy.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/extensions/dom_action_types.h"
+#include "chrome/common/extensions/extension.h"
+#include "googleurl/src/gurl.h"
+#include "sql/error_delegate_util.h"
+
+using base::Callback;
+using base::FilePath;
+using base::Time;
+using base::Unretained;
+using content::BrowserThread;
+
+namespace {
+
+// Key strings for passing parameters to the ProcessAction member function.
+const char kKeyReason[] =         "fsuip.reason";
+const char kKeyDomainAction[] =   "fsuip.domact";
+const char kKeyURLTitle[] =       "fsuip.urltitle";
+const char kKeyDetailsString[] =  "fsuip.details";
+
+}  // namespace
+
+namespace extensions {
+
+// TODO(dbabic) This would be a fine error handler for all sql-based policies,
+// so it would make sense to introduce another class in the hierarchy,
+// SQLiteBasedPolicy as a super class of FullStreamUIPolicy and move this
+// error handler (as well as other SQLite-related functionality) there.
+
+FullStreamUIPolicy::FullStreamUIPolicy(
+    Profile* profile,
+    content::BrowserThread::ID thread_id)
+    : ActivityLogPolicy(profile, thread_id) {
+  // We normally dispatch DB requests to the DB thread, but the thread might
+  // not exist if we are under test conditions. Substitute the UI thread for
+  // this case.
+  if (BrowserThread::IsMessageLoopValid(BrowserThread::DB)) {
+    dispatch_thread_ = BrowserThread::DB;
+  } else {
+    LOG(ERROR) << "BrowserThread::DB does not exist, running on UI thread!";
+    dispatch_thread_ = BrowserThread::UI;

[felt, 2013/06/13 20:24:16]

Hey, during my last bug scrub I got rid of this dispatch_thread_ stuff. Now, we
don't dispatch at all if either the IO, DB, or FILE threads are missing.

[dbabic, 2013/06/13 23:10:08]

Done.

+  }
+
+  db_ = new ActivityDatabase();
+  FilePath database_name = profile_base_path_.Append(
+      chrome::kExtensionActivityLogFilename);
+  ScheduleAndForget(db_, &ActivityDatabase::Init, database_name);
+}
+
+FullStreamUIPolicy::~FullStreamUIPolicy() {
+  ScheduleAndForget(db_, &ActivityDatabase::Close);

[felt, 2013/06/13 20:24:16]

If the IO, DB, ir FILE threads are missing you need to delete db_; instead of
calling ::Close.

[dbabic, 2013/06/13 23:10:08]

Done. If the DB thread is missing, the policy will never get created in the
first place.  I've added a check.

+}
+
+// Get data as a set of key-value pairs.  The keys are policy-specific.
+void FullStreamUIPolicy::ReadData(
+    const std::string& extension_id,
+    const int day,
+    const Callback
+        <void(scoped_ptr<std::vector<scoped_refptr<Action> > >)>& callback)
+    const {
+  BrowserThread::PostTaskAndReplyWithResult(
+      dispatch_thread_,
+      FROM_HERE,
+      base::Bind(&ActivityDatabase::GetActions, Unretained(db_),
+                 extension_id, day),
+      callback);
+}
+
+void FullStreamUIPolicy::SetSaveStateOnRequestOnly() {
+  db_->SetBatchModeForTesting(false);

[felt, 2013/06/13 20:24:16]

Hey, I just noticed that you're doing this from the UI thread. Either dispatch
this asynchronously on the DB thread or make sure that the bool inside
SetBatchModeForTesting is threadsafe (add a Lock to the class and an AutoLock in
the method scope).

[dbabic, 2013/06/13 23:10:08]

This should all be running on the DB thread.  If there's no DB thread, the
policy object won't get created.

[felt, 2013/06/14 04:29:02]

I'm confused. Where is SetSaveStateOnRequestOnly dispatched on the DB thread? It
looks like the UI thread to me?

On 2013/06/13 23:10:08, dbabic wrote:

+  ActivityLogPolicy::SetSaveStateOnRequestOnly();
+}
+
+void FullStreamUIPolicy::GetKey(ActivityLogPolicy::KeyType key_ty,
+    std::string* key) const {
+  DCHECK(key && "Unexpected NULL pointer.");
+  switch (key_ty) {
+    case PARAM_KEY_REASON:
+      *key = kKeyReason;
+      break;
+    case PARAM_KEY_DOM_ACTION:
+      *key = kKeyDomainAction;
+      break;
+    case PARAM_KEY_URL_TITLE:
+      *key = kKeyURLTitle;
+      break;
+    case PARAM_KEY_DETAILS_STRING:
+      *key = kKeyDetailsString;
+      break;
+    default:
+      *key = "";
+  }
+}
+
+void FullStreamUIPolicy::ProcessArguments(
+    ActionType action_type,
+    const std::string& name,
+    const ListValue* args,
+    std::string* processed_args) const {
+  if (args) {
+    ListValue::const_iterator it = args->begin();
+    // TODO(felt,dbabic) Think about replacing the loop with a single
+    // call to SerializeAndOmitBinaryValues.
+    for (; it != args->end(); ++it) {
+      std::string arg;
+      JSONStringValueSerializer serializer(&arg);
+      if (serializer.SerializeAndOmitBinaryValues(**it)) {
+        if (it != args->begin()) {
+          processed_args->append(", ");
+        }
+        processed_args->append(arg);
+      }
+    }
+  }
+}
+
+void FullStreamUIPolicy::ProcessWebRequestModifications(
+    DictionaryValue& details,
+    std::string& details_string) const {
+  JSONStringValueSerializer serializer(&details_string);
+  serializer.Serialize(details);
+}
+
+void FullStreamUIPolicy::ProcessAction(
+    ActionType action_type,
+    const std::string& extension_id,
+    const std::string& name,
+    const GURL* url_param,
+    const ListValue* args,
+    const DictionaryValue* details) {
+  std::string concatenated_args;
+  ProcessArguments(action_type, name, args, &concatenated_args);
+  const Time now = Time::Now();
+  // TODO(dbabic,felt) Drop the dummy string in the next revision

[felt, 2013/06/13 20:24:16]

What's the dummy string? Is that the extra? Can you drop this TODO and rename
extras, since we've started finding use cases for having extras.

[dbabic, 2013/06/13 23:10:08]

Done.  It's now the extra string.

+  const std::string dummy;
+  GURL url_obj;
+  if (url_param) {
+    url_obj = *url_param;
+  }
+  scoped_refptr<Action> action;
+
+  switch (action_type) {
+    case ACTION_API: {
+      action = new APIAction(
+          extension_id,
+          now,
+          APIAction::CALL,
+          name,
+          concatenated_args,
+          dummy); // TODO(dbabic,felt) Drop in the next revision
+      break;
+    }
+    case ACTION_EVENT: {
+      action = new APIAction(
+          extension_id,
+          now,
+          APIAction::EVENT_CALLBACK,
+          name,
+          concatenated_args,
+          dummy); // TODO(dbabic,felt) Drop in the next revision
+      break;
+    }
+    case ACTION_BLOCKED: {
+      std::string key;
+      int reason = 0;
+      if (details) {
+        GetKey(PARAM_KEY_REASON, &key);
+        details->GetInteger(key, &reason);
+      }
+
+      action = new BlockedAction(
+          extension_id,
+          now,
+          name,
+          concatenated_args,
+          static_cast<BlockedAction::Reason>(reason),
+          dummy); // TODO(dbabic,felt) Drop in the next revision
+      break;
+    }
+    case ACTION_DOM: {
+      std::string key;
+      string16 value;
+      DomActionType::Type action_type = DomActionType::MODIFIED;
+
+      if (details) {
+        int action_id = 0;
+        GetKey(PARAM_KEY_DOM_ACTION, &key);
+        details->GetInteger(key, &action_id);
+        action_type = static_cast<DomActionType::Type>(action_id);
+        GetKey(PARAM_KEY_URL_TITLE, &key);
+        details->GetString(key, &value);
+      }
+
+      action = new DOMAction(
+          extension_id,
+          now,
+          action_type,
+          url_obj,
+          value,
+          name,
+          concatenated_args,
+          dummy); // TODO(dbabic,felt) Drop in the next revision
+      break;
+    }
+    case ACTION_WEB_REQUEST: {
+      std::string key;
+      std::string details_string;
+      if (details) {
+        scoped_ptr<DictionaryValue> copy_of_details(details->DeepCopy());
+        GetKey(PARAM_KEY_DETAILS_STRING, &key);
+        ProcessWebRequestModifications(*copy_of_details.get(), details_string);
+      }
+
+      action = new DOMAction(
+          extension_id,
+          now,
+          DomActionType::WEBREQUEST,
+          url_obj,
+          string16(),
+          name,
+          details_string,
+          dummy); // TODO(dbabic,felt) Drop in the next revision
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+
+  ScheduleAndForget(db_, &ActivityDatabase::RecordAction, action);
+}
+
+}  // namespace extensions