Metrics for feature engagement tracker.

components/feature_engagement_tracker/internal/availability_store.cc

 // Copyright 2017 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/feature_engagement_tracker/internal/availability_store.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "components/feature_engagement_tracker/internal/proto/availability.pb.h"
+#include "components/feature_engagement_tracker/internal/stats.h"
 #include "components/feature_engagement_tracker/public/feature_list.h"
 #include "components/leveldb_proto/proto_database.h"
 
 namespace feature_engagement_tracker {
 
 namespace {
 
 using KeyAvailabilityPair = std::pair<std::string, Availability>;
 using KeyAvailabilityList = std::vector<KeyAvailabilityPair>;
 
 // Corresponds to a UMA suffix "LevelDBOpenResults" in histograms.xml.
 // Please do not change.
 const char kDatabaseUMAName[] = "FeatureEngagementTrackerAvailabilityStore";
 
 void OnDBUpdateComplete(
     std::unique_ptr<leveldb_proto::ProtoDatabase<Availability>> db,
     AvailabilityStore::OnLoadedCallback on_loaded_callback,
     std::unique_ptr<std::map<const base::Feature*, uint32_t>>
         feature_availabilities,
     bool success) {
+  stats::RecordDbUpdate(success, stats::StoreType::AVAILABILITY_STORE);
   std::move(on_loaded_callback).Run(success, std::move(feature_availabilities));
 }
 
 void OnDBLoadComplete(
     std::unique_ptr<leveldb_proto::ProtoDatabase<Availability>> db,
     FeatureVector feature_filter,
     AvailabilityStore::OnLoadedCallback on_loaded_callback,
     uint32_t current_day,
     bool success,
     std::unique_ptr<std::vector<Availability>> availabilities) {
+  stats::RecordAvailabilityDbLoadEvent(success);
   if (!success) {
     std::move(on_loaded_callback)
         .Run(false,
              base::MakeUnique<std::map<const base::Feature*, uint32_t>>());
     return;
   }
 
   // Create map from feature name to Feature.
   std::map<std::string, const base::Feature*> feature_mapping;
   for (const base::Feature* feature : feature_filter) {
@@ skipping 52 matching lines @@
                                    std::move(on_loaded_callback),
                                    std::move(feature_availabilities)));
 }
 
 void OnDBInitComplete(
     std::unique_ptr<leveldb_proto::ProtoDatabase<Availability>> db,
     FeatureVector feature_filter,
     AvailabilityStore::OnLoadedCallback on_loaded_callback,
     uint32_t current_day,
     bool success) {
+  stats::RecordDbInitEvent(success, stats::StoreType::AVAILABILITY_STORE);
+
   if (!success) {
     std::move(on_loaded_callback)
         .Run(false,
              base::MakeUnique<std::map<const base::Feature*, uint32_t>>());
     return;
   }
 
   db->LoadEntries(base::BindOnce(&OnDBLoadComplete, std::move(db),
                                  std::move(feature_filter),
                                  std::move(on_loaded_callback), current_day));
 }
 
 }  // namespace
 
 // static
 void AvailabilityStore::LoadAndUpdateStore(
     const base::FilePath& storage_dir,
     std::unique_ptr<leveldb_proto::ProtoDatabase<Availability>> db,
     FeatureVector feature_filter,
     AvailabilityStore::OnLoadedCallback on_loaded_callback,
     uint32_t current_day) {
   db->Init(kDatabaseUMAName, storage_dir,
            base::BindOnce(&OnDBInitComplete, std::move(db),
                           std::move(feature_filter),
                           std::move(on_loaded_callback), current_day));
 }
 
 }  // namespace feature_engagement_tracker