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);
+  DCHECK(io_thread);
+  DCHECK(io_thread->globals());
+
+  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;
+}
+
+#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()) {

[mmenke, 2015/12/01 16:45:49]

The off the record check isn't actually needed - I meant to point out that this
file is only for on the record events, in case you thought you were gathering
everything.

[tbansal1, 2015/12/01 20:00:07]

Got it. I previously verified that ProfileImplIOData was constructed with 
REGULAR_PROFILE. So, I thought you just want me to add an additional check.

+    BrowserThread::PostTaskAndReplyWithResult(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&SetDataUseTabModelOnIOThread,
+                   g_browser_process->io_thread(),
+                   data_use_ui_tab_model->GetWeakPtr()),
+        base::Bind(&chrome::android::DataUseUITabModel::SetDataUseTabModel,
+                   data_use_ui_tab_model->GetWeakPtr()));

[mmenke, 2015/12/01 16:45:49]

Seems like we're micromanaging DataUseUITabModel's internal state and setup
here.  None of this code even cares about ProfileIOData.

Could we just add a call to DataUseUITabModelFactory::GetInstance() in
chrome_browser_main_extra_parts_profiles.cc, have it grab the IOThread pointer
there, and do all this setup itself in its constructor?  Instantiating the
service should guarantee it gets created.

Also means we wouldn't have to expose weak pointers to the world, which is
generally a good thing to not do.

You'll need to be careful about handling off the record correctly.

[tbansal1, 2015/12/01 20:00:07]

Done.

+  }
+#endif  // defined(OS_ANDROID)
 }
 
 content::ResourceContext*
     ProfileImplIOData::Handle::GetResourceContext() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   LazyInitialize();
   return GetResourceContextNoInit();
 }
 
 content::ResourceContext*
@@ skipping 571 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);
 }