Compressed activity log database storage

chrome/browser/extensions/activity_log/activity_actions.cc

 // Copyright (c) 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/activity_actions.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/activity_log/activity_action_constants.h"
-#include "chrome/browser/extensions/activity_log/api_name_constants.h"
 #include "chrome/browser/extensions/activity_log/fullstream_ui_policy.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "sql/statement.h"
 
 namespace constants = activity_log_constants;
 
 namespace {
 
 std::string Serialize(const base::Value* value) {
   std::string value_as_text;
   if (!value) {
     value_as_text = "null";
   } else {
     JSONStringValueSerializer serializer(&value_as_text);
     serializer.SerializeAndOmitBinaryValues(*value);
   }
   return value_as_text;
 }
 
-// Sets up the hashmap for mapping extension strings to "ints". The hashmap is
-// only set up once because it's quite long; the value is then cached.
-class APINameMap {
- public:
-  APINameMap() {
-    SetupMap();
-  }
-
-  // activity_log_api_name_constants.h lists all known API calls as of 5/17.
-  // This code maps each of those API calls (and events) to short strings
-  // (integers converted to strings). They're all strings because (1) sqlite
-  // databases are all strings underneath anyway and (2) the Lookup function
-  // will simply return the original api_call string if we don't have it in our
-  // lookup table.
-  void SetupMap() {
-    for (size_t i = 0;
-         i < arraysize(activity_log_api_name_constants::kNames);
-         ++i) {
-      std::string name =
-          std::string(activity_log_api_name_constants::kNames[i]);
-      std::string num = base::IntToString(i);
-      names_to_nums_[name] = num;
-      nums_to_names_[num] = name;
-    }
-  }
-
-  static APINameMap* GetInstance() {
-    return Singleton<APINameMap>::get();
-  }
-
-  // This matches an api call to a number, if it's in the lookup table. If not,
-  // it returns the original api call.
-  const std::string& ApiToShortname(const std::string& api_call) {
-    std::map<std::string, std::string>::iterator it =
-        names_to_nums_.find(api_call);
-    if (it == names_to_nums_.end())
-      return api_call;
-    else
-      return it->second;
-  }
-
-  // This matches a number to an API call -- it's the opposite of
-  // ApiToShortname.
-  const std::string& ShortnameToApi(const std::string& shortname) {
-    std::map<std::string, std::string>::iterator it =
-        nums_to_names_.find(shortname);
-    if (it == nums_to_names_.end())
-      return shortname;
-    else
-      return it->second;
-  }
-
- private:
-  std::map<std::string, std::string> names_to_nums_;  // <name, number label>
-  std::map<std::string, std::string> nums_to_names_;  // <number label, name>
-};
-
 }  // namespace
 
 namespace extensions {
 
 using api::activity_log_private::BlockedChromeActivityDetail;
 using api::activity_log_private::ChromeActivityDetail;
 using api::activity_log_private::DomActivityDetail;
 using api::activity_log_private::ExtensionActivity;
 
 Action::Action(const std::string& extension_id,
@@ skipping 50 matching lines @@
   other_.reset(other.release());
 }
 
 DictionaryValue* Action::mutable_other() {
   if (!other_.get()) {
     other_.reset(new DictionaryValue());
   }
   return other_.get();
 }
 
+std::string Action::SerializePageUrl() const {
+  return (page_incognito() ? constants::kIncognitoUrl : "") + page_url().spec();
+}
+
+void Action::ParsePageUrl(const std::string& url) {
+  set_page_incognito(StartsWithASCII(url, constants::kIncognitoUrl, true));
+  if (page_incognito())
+    set_page_url(GURL(url.substr(strlen(constants::kIncognitoUrl))));
+  else
+    set_page_url(GURL(url));
+}
+
+std::string Action::SerializeArgUrl() const {
+  return (arg_incognito() ? constants::kIncognitoUrl : "") + arg_url().spec();
+}
+
+void Action::ParseArgUrl(const std::string& url) {
+  set_arg_incognito(StartsWithASCII(url, constants::kIncognitoUrl, true));
+  if (arg_incognito())
+    set_arg_url(GURL(url.substr(strlen(constants::kIncognitoUrl))));
+  else
+    set_arg_url(GURL(url));
+}
+
 scoped_ptr<ExtensionActivity> Action::ConvertToExtensionActivity() {
   scoped_ptr<ExtensionActivity> result(new ExtensionActivity);
 
   result->extension_id.reset(new std::string(extension_id()));
   result->time.reset(new double(time().ToJsTime()));
 
   switch (action_type()) {
     case ACTION_API_CALL:
     case ACTION_API_EVENT: {
       ChromeActivityDetail* details = new ChromeActivityDetail;
@@ skipping 63 matching lines @@
     }
 
     default:
       LOG(WARNING) << "Bad activity log entry read from database (type="
                    << action_type_ << ")!";
   }
 
   return result.Pass();
 }
 
-std::string Action::PrintForDebug() {
+std::string Action::PrintForDebug() const {
   std::string result = "ID=" + extension_id() + " CATEGORY=";
   switch (action_type_) {
     case ACTION_API_CALL:
       result += "api_call";
       break;
     case ACTION_API_EVENT:
       result += "api_event_callback";
       break;
     case ACTION_WEB_REQUEST:
       result += "webrequest";
@@ skipping 35 matching lines @@
       result += " ARG_URL=" + arg_url_.spec();
   }
   if (other_.get()) {
     result += " OTHER=" + Serialize(other_.get());
   }
 
   return result;
 }
 
 }  // namespace extensions