Notify DataUseTabModel of navigations and tab closures

chrome/browser/profiles/profile_impl_io_data.cc

 // Copyright (c) 2012 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/profiles/profile_impl_io_data.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 47 matching lines @@
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/android/data_usage/data_use_tab_model.h"
+#include "chrome/browser/android/data_usage/data_use_ui_tab_model.h"
+#include "chrome/browser/android/data_usage/data_use_ui_tab_model_factory.h"
+#include "chrome/browser/android/data_usage/external_data_use_observer.h"
+#endif  // defined(OS_ANDROID)
+
 namespace {
 
 net::BackendType ChooseCacheBackendType() {
 #if defined(OS_ANDROID)
   return net::CACHE_BACKEND_SIMPLE;
 #else
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kUseSimpleCacheBackend)) {
     const std::string opt_value =
         command_line.GetSwitchValueASCII(switches::kUseSimpleCacheBackend);
     if (base::LowerCaseEqualsASCII(opt_value, "off"))
       return net::CACHE_BACKEND_BLOCKFILE;
     if (opt_value.empty() || base::LowerCaseEqualsASCII(opt_value, "on"))
       return net::CACHE_BACKEND_SIMPLE;
   }
   const std::string experiment_name =
       base::FieldTrialList::FindFullName("SimpleCacheTrial");
   if (experiment_name == "ExperimentYes" ||
       experiment_name == "ExperimentYes2") {
     return net::CACHE_BACKEND_SIMPLE;
   }
   return net::CACHE_BACKEND_BLOCKFILE;
 #endif
 }
 
+#if defined(OS_ANDROID)
+// Returns the weak pointer to DataUseTabModel, and adds |data_use_ui_tab_model|
+// as an observer to DataUseTabModel. Must be called only on IO thread.
+base::WeakPtr<chrome::android::DataUseTabModel> SetDataUseTabModelOnIOThread(
+    IOThread* io_thread,
+    base::WeakPtr<chrome::android::DataUseUITabModel> data_use_ui_tab_model) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  if (!io_thread || !io_thread->globals())
+    return base::WeakPtr<chrome::android::DataUseTabModel>();
+
+  base::WeakPtr<chrome::android::DataUseTabModel> data_use_tab_model =
+      io_thread->globals()
+          ->external_data_use_observer->GetDataUseTabModel()
+          ->GetWeakPtr();
+  if (data_use_tab_model)
+    data_use_tab_model->AddObserver(data_use_ui_tab_model);
+  return data_use_tab_model;
+}
+
+// Passes the weak pointer to DataUseTabModel to |data_use_ui_tab_model|. Must
+// be called only on UI thread.
+void SetDataUseTabModelOnUIThread(
+    base::WeakPtr<chrome::android::DataUseUITabModel> data_use_ui_tab_model,
+    base::WeakPtr<chrome::android::DataUseTabModel> data_use_tab_model) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  data_use_ui_tab_model->SetDataUseTabModel(data_use_tab_model);
+}
+#endif  // defined(OS_ANDROID)
+
 }  // namespace
 
 using content::BrowserThread;
 
 ProfileImplIOData::Handle::Handle(Profile* profile)
     : io_data_(new ProfileImplIOData),
       profile_(profile),
       initialized_(false) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(profile);
@@ skipping 88 matching lines @@
           pool->GetSequenceToken(),
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   scoped_ptr<data_reduction_proxy::DataStore> store(
       new data_reduction_proxy::DataStoreImpl(profile_path));
   DataReductionProxyChromeSettingsFactory::GetForBrowserContext(profile_)
       ->InitDataReductionProxySettings(
           io_data_->data_reduction_proxy_io_data(), profile_->GetPrefs(),
           profile_->GetRequestContext(), store.Pass(),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
           db_task_runner);
+
+#if defined(OS_ANDROID)
+  // Pass the DataUseTabModel weak pointer to DataUseUITabModel, and register
+  // DataUseUITabModel as a DataUseTabModel::TabDataUseObserver.
+  chrome::android::DataUseUITabModel* data_use_ui_tab_model =
+      chrome::android::DataUseUITabModelFactory::GetForBrowserContext(profile_);
+
+  if (data_use_ui_tab_model && !io_data_->IsOffTheRecord()) {
+    BrowserThread::PostTaskAndReplyWithResult(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&SetDataUseTabModelOnIOThread,
+                   g_browser_process->io_thread(),
+                   data_use_ui_tab_model->GetWeakPtr()),
+        base::Bind(&SetDataUseTabModelOnUIThread,

[sclittle, 2015/11/25 22:49:11]

You could just bind &chrome::android::DataUseUITabModel::SetDataUseTabModel here
directly instead of using an anonymous function.

[tbansal1, 2015/11/26 00:31:21]

Done.

+                   data_use_ui_tab_model->GetWeakPtr()));
+  }
+#endif  // defined(OS_ANDROID)
 }
 
 content::ResourceContext*
     ProfileImplIOData::Handle::GetResourceContext() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   LazyInitialize();
   return GetResourceContextNoInit();
 }
 
 content::ResourceContext*
@@ skipping 572 matching lines @@
     const base::Closure& completion) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }