src/chrome/test/chromedriver/performance_logger.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <vector>
   7
   8 #include "chrome/test/chromedriver/performance_logger.h"
   9
  10 #include "base/json/json_writer.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/values.h"
  13 #include "chrome/test/chromedriver/chrome/devtools_client.h"
  14 #include "chrome/test/chromedriver/chrome/devtools_client_impl.h"
  15 #include "chrome/test/chromedriver/chrome/log.h"
  16 #include "chrome/test/chromedriver/chrome/status.h"
  17
  18 namespace {
  19
  20 // DevTools event domain prefixes to intercept.
  21 const char* const kDomains[] = {"Network.", "Page.", "Timeline."};
  22
  23 // Returns whether the event belongs to one of kDomains.
  24 bool ShouldLogEvent(const std::string& method) {
  25   for (size_t i_domain = 0; i_domain < arraysize(kDomains); ++i_domain) {
  26     if (StartsWithASCII(method, kDomains[i_domain], true /* case_sensitive */))
  27       return true;
  28   }
  29   return false;
  30 }
  31
  32 bool IsEnabled(const PerfLoggingPrefs::InspectorDomainStatus& domain_status) {
  33   return (domain_status ==
  34           PerfLoggingPrefs::InspectorDomainStatus::kDefaultEnabled ||
  35           domain_status ==
  36           PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyEnabled);
  37 }
  38
  39 }  // namespace
  40
  41 PerformanceLogger::PerformanceLogger(Log* log)
  42     : log_(log) {}
  43
  44 PerformanceLogger::PerformanceLogger(Log* log, const PerfLoggingPrefs& prefs)
  45     : log_(log),
  46       prefs_(prefs) {
  47   if (!prefs_.trace_categories.empty()) {
  48     LOG(WARNING) << "Ignoring trace categories because tracing support not yet "
  49                  << "implemented: " << prefs_.trace_categories;
  50     prefs_.trace_categories = "";
  51   }
  52 }
  53
  54 bool PerformanceLogger::subscribes_to_browser() {
  55   return true;
  56 }
  57
  58 Status PerformanceLogger::OnConnected(DevToolsClient* client) {
  59   if (client->GetId() == DevToolsClientImpl::kBrowserwideDevToolsClientId) {
  60     // TODO(johnmoore): Implement tracing log.
  61     return Status(kOk);
  62   }
  63   std::vector<std::string> enable_commands;
  64   if (IsEnabled(prefs_.network))
  65     enable_commands.push_back("Network.enable");
  66   if (IsEnabled(prefs_.page))
  67     enable_commands.push_back("Page.enable");
  68   if (IsEnabled(prefs_.timeline)) {
  69     // Timeline feed implicitly disabled when trace categories are specified.
  70     // So even if kDefaultEnabled, don't enable unless empty |trace_categories|.
  71     if (prefs_.trace_categories.empty() || prefs_.timeline ==
  72         PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyEnabled)
  73       enable_commands.push_back("Timeline.start");
  74   }
  75   for (std::vector<std::string>::const_iterator it = enable_commands.begin();
  76        it != enable_commands.end(); ++it) {
  77     base::DictionaryValue params;  // All the enable commands have empty params.
  78     Status status = client->SendCommand(*it, params);
  79     if (status.IsError())
  80       return status;
  81   }
  82   return Status(kOk);
  83 }
  84
  85 Status PerformanceLogger::OnEvent(
  86     DevToolsClient* client,
  87     const std::string& method,
  88     const base::DictionaryValue& params) {
  89   if (!ShouldLogEvent(method))
  90     return Status(kOk);
  91
  92   base::DictionaryValue log_message_dict;
  93   log_message_dict.SetString("webview", client->GetId());
  94   log_message_dict.SetString("message.method", method);
  95   log_message_dict.Set("message.params", params.DeepCopy());
  96   std::string log_message_json;
  97   // TODO(klm): extract timestamp from params?
  98   // Look at where it is for Page, Network, Timeline events.
  99   base::JSONWriter::Write(&log_message_dict, &log_message_json);
 100
 101   log_->AddEntry(Log::kInfo, log_message_json);
 102   return Status(kOk);
 103 }
 104
 105 // TODO(johnmoore): Use BeforeCommand to implement tracing log.
 106 Status PerformanceLogger::BeforeCommand(const std::string& command_name) {
 107   return Status(kOk);
 108 }