components/metrics/test_metrics_service_client.cc

// Copyright 2014 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 "components/metrics/test_metrics_service_client.h"

#include <memory>

#include "base/callback.h"
#include "components/metrics/metrics_log_uploader.h"
#include "components/metrics/proto/chrome_user_metrics_extension.pb.h"

namespace metrics {

namespace {

class TestMetricsLogUploader : public MetricsLogUploader {
 public:
  TestMetricsLogUploader(const std::string& server_url,
                         const std::string& mime_type,
                         const base::Callback<void(int)>& on_upload_complete)
      : MetricsLogUploader(server_url, mime_type, on_upload_complete) {}
  ~TestMetricsLogUploader() override = default;

  // MetricsLogUploader:
  void UploadLog(const std::string& compressed_log_data,
                 const std::string& log_hash) override {
    // Never succeeds at uploading.
    on_upload_complete_.Run(404);
  }
};

}  // namespace

// static
const char TestMetricsServiceClient::kBrandForTesting[] = "brand_for_testing";

TestMetricsServiceClient::TestMetricsServiceClient()
    : version_string_("5.0.322.0-64-devel"),
      product_(ChromeUserMetricsExtension::CHROME),
      reporting_is_managed_(false),
      enable_default_(EnableMetricsDefault::DEFAULT_UNKNOWN) {}

TestMetricsServiceClient::~TestMetricsServiceClient() {
}

metrics::MetricsService* TestMetricsServiceClient::GetMetricsService() {
  return nullptr;
}

void TestMetricsServiceClient::SetMetricsClientId(
    const std::string& client_id) {
  client_id_ = client_id;
}

int32_t TestMetricsServiceClient::GetProduct() {
  return product_;
}

std::string TestMetricsServiceClient::GetApplicationLocale() {
  return "en-US";
}

bool TestMetricsServiceClient::GetBrand(std::string* brand_code) {
  *brand_code = kBrandForTesting;
  return true;
}

SystemProfileProto::Channel TestMetricsServiceClient::GetChannel() {
  return SystemProfileProto::CHANNEL_BETA;
}

std::string TestMetricsServiceClient::GetVersionString() {
  return version_string_;
}

void TestMetricsServiceClient::InitializeSystemProfileMetrics(
    const base::Closure& done_callback) {
  done_callback.Run();
}

void TestMetricsServiceClient::CollectFinalMetricsForLog(
    const base::Closure& done_callback) {
  done_callback.Run();
}

std::unique_ptr<MetricsLogUploader> TestMetricsServiceClient::CreateUploader(
    const std::string& server_url,
    const std::string& mime_type,
    const base::Callback<void(int)>& on_upload_complete) {
  return std::unique_ptr<MetricsLogUploader>(
      new TestMetricsLogUploader(server_url, mime_type, on_upload_complete));
}

base::TimeDelta TestMetricsServiceClient::GetStandardUploadInterval() {
  return base::TimeDelta::FromMinutes(5);
}

bool TestMetricsServiceClient::IsReportingPolicyManaged() {
  return reporting_is_managed_;
}

EnableMetricsDefault
TestMetricsServiceClient::GetMetricsReportingDefaultState() {
  return enable_default_;
}

}  // namespace metrics