Add initial Controller to DownloadService

components/download/internal/model_impl.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/download/internal/model_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "components/download/internal/entry.h"
+#include "components/download/internal/stats.h"
 
 namespace download {
 
-ModelImpl::ModelImpl(Client* client, std::unique_ptr<Store> store)
-    : client_(client), store_(std::move(store)), weak_ptr_factory_(this) {
-  DCHECK(client_);
+ModelImpl::ModelImpl(std::unique_ptr<Store> store)
+    : client_(nullptr), store_(std::move(store)), weak_ptr_factory_(this) {
   DCHECK(store_);
 }
 
 ModelImpl::~ModelImpl() = default;
 
-void ModelImpl::Initialize() {
+void ModelImpl::Initialize(Client* client) {
+  DCHECK(!client_);
+  client_ = client;
+  DCHECK(client_);
+
   DCHECK(!store_->IsInitialized());
-  store_->Initialize(base::BindOnce(&ModelImpl::OnInitializedFinished,
-                                    weak_ptr_factory_.GetWeakPtr()));
+  store_->Initialize(base::Bind(&ModelImpl::OnInitializedFinished,
+                                weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ModelImpl::Add(const Entry& entry) {
   DCHECK(store_->IsInitialized());
   DCHECK(entries_.find(entry.guid) == entries_.end());
 
   entries_.emplace(entry.guid, base::MakeUnique<Entry>(entry));
 
   store_->Update(entry, base::BindOnce(&ModelImpl::OnAddFinished,
                                        weak_ptr_factory_.GetWeakPtr(),
@@ skipping 32 matching lines @@
   EntryList entries;
   for (const auto& it : entries_)
     entries.push_back(it.second.get());
 
   return entries;
 }
 
 void ModelImpl::OnInitializedFinished(
     bool success,
     std::unique_ptr<std::vector<Entry>> entries) {
+  stats::LogModelOperationResult(stats::ModelAction::INITIALIZE, success);
+
   if (!success) {
-    client_->OnInitialized(false);
+    client_->OnModelReady(false);
     return;
   }
 
   for (const auto& entry : *entries)
     entries_.emplace(entry.guid, base::MakeUnique<Entry>(entry));
 
-  client_->OnInitialized(true);
+  client_->OnModelReady(true);
 }
 
 void ModelImpl::OnAddFinished(DownloadClient client,
                               const std::string& guid,
                               bool success) {
+  stats::LogModelOperationResult(stats::ModelAction::ADD, success);
+
   // Don't notify the Client if the entry was already removed.
   if (entries_.find(guid) == entries_.end())
     return;
 
   // Remove the entry from the map if the add failed.
   if (!success)
     entries_.erase(guid);
 
   client_->OnItemAdded(success, client, guid);
 }
 
 void ModelImpl::OnUpdateFinished(DownloadClient client,
                                  const std::string& guid,
                                  bool success) {
+  stats::LogModelOperationResult(stats::ModelAction::UPDATE, success);
+
   // Don't notify the Client if the entry was already removed.
   if (entries_.find(guid) == entries_.end())
     return;
 
   client_->OnItemUpdated(success, client, guid);
 }
 
 void ModelImpl::OnRemoveFinished(DownloadClient client,
                                  const std::string& guid,
                                  bool success) {
+  stats::LogModelOperationResult(stats::ModelAction::REMOVE, success);
+
   DCHECK(entries_.find(guid) == entries_.end());
   client_->OnItemRemoved(success, client, guid);
 }
 
 }  // namespace download