Miscellaneous fixes to DataUse UI

chrome/browser/android/data_usage/data_use_ui_tab_model.cc

 // Copyright 2015 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/android/data_usage/data_use_ui_tab_model.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 43 matching lines @@
 
   // Clear out local state.
   TabEvents::iterator it = tab_events_.find(tab_id);
   if (it == tab_events_.end())
     return;
   tab_events_.erase(it);
 }
 
 void DataUseUITabModel::ReportCustomTabInitialNavigation(
     SessionID::id_type tab_id,
-    const std::string& url,
-    const std::string& package_name) {
+    const std::string& package_name,
+    const std::string& url) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (tab_id <= 0)
     return;
 
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DataUseTabModel::OnNavigationEvent, data_use_tab_model_,
                  tab_id, DataUseTabModel::TRANSITION_CUSTOM_TAB, GURL(url),
                  package_name));
 }
 
 void DataUseUITabModel::SetDataUseTabModel(
     base::WeakPtr<DataUseTabModel> data_use_tab_model) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_use_tab_model_ = data_use_tab_model;
 }
 
 base::WeakPtr<DataUseUITabModel> DataUseUITabModel::GetWeakPtr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_factory_.GetWeakPtr();
 }
 
 void DataUseUITabModel::NotifyTrackingStarting(SessionID::id_type tab_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  RemoveTabEvent(tab_id, DATA_USE_CONTINUE_CLICKED);

[megjablon, 2015/12/18 20:17:53]

Add comment why this is here.

[tbansal1, 2015/12/18 21:35:37]

Done.

+
   if (MaybeCreateTabEvent(tab_id, DATA_USE_TRACKING_STARTED))
     return;
   // Since tracking started before the UI could indicate that it ended, it is
   // not useful for UI to show that it started again.
   RemoveTabEvent(tab_id, DATA_USE_TRACKING_ENDED);
 }
 
 void DataUseUITabModel::NotifyTrackingEnding(SessionID::id_type tab_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (MaybeCreateTabEvent(tab_id, DATA_USE_TRACKING_ENDED))
     return;
   // Since tracking ended before the UI could indicate that it stated, it is not
   // useful for UI to show that it ended.
   RemoveTabEvent(tab_id, DATA_USE_TRACKING_STARTED);
+
+  // If the user clicked "Continue" before this navigation, then we do not need
+  // to show another UI on this tab.
+  RemoveTabEvent(tab_id, DATA_USE_CONTINUE_CLICKED);

[megjablon, 2015/12/18 20:17:53]

Won't MaybeCreateTabEvent create the event and return before you get here?

[tbansal1, 2015/12/18 21:35:37]

Added comments in the file. Done.

If the state was set to "DATA_USE_CONTINUE_CLICKED", then MaybeCreateEvent would
have failed above.

 }
 
 bool DataUseUITabModel::HasDataUseTrackingStarted(SessionID::id_type tab_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   TabEvents::iterator it = tab_events_.find(tab_id);
   if (it == tab_events_.end())
     return false;
 
   return RemoveTabEvent(tab_id, DATA_USE_TRACKING_STARTED);
 }
 
+bool DataUseUITabModel::WouldDataUseTrackingEnd(
+    const std::string& url,
+    int page_transition,
+    SessionID::id_type tab_id) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  TabEvents::const_iterator it = tab_events_.find(tab_id);
+
+  if (it != tab_events_.end() && it->second == DATA_USE_CONTINUE_CLICKED)
+    return false;
+
+  DataUseTabModel::TransitionType transition_type;
+
+  if (!ConvertTransitionType(ui::PageTransitionFromInt(page_transition),
+                             &transition_type)) {
+    return false;
+  }
+
+  // TODO(tbansal): Hook up to DataUseTabModel, and add tests.
+  return false;
+}
+
+void DataUseUITabModel::UserClickedContinueOnDialogBox(
+    SessionID::id_type tab_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  TabEvents::iterator it = tab_events_.find(tab_id);
+  if (it != tab_events_.end())
+    tab_events_.erase(it);
+
+  MaybeCreateTabEvent(tab_id, DATA_USE_CONTINUE_CLICKED);
+}
+
 bool DataUseUITabModel::HasDataUseTrackingEnded(SessionID::id_type tab_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   TabEvents::iterator it = tab_events_.find(tab_id);
   if (it == tab_events_.end())
     return false;
 
   return RemoveTabEvent(tab_id, DATA_USE_TRACKING_ENDED);
 }
 
 bool DataUseUITabModel::MaybeCreateTabEvent(SessionID::id_type tab_id,
                                             DataUseTrackingEvent event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return tab_events_.insert(std::make_pair(tab_id, event)).second;
 }
 
 bool DataUseUITabModel::RemoveTabEvent(SessionID::id_type tab_id,
                                        DataUseTrackingEvent event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TabEvents::iterator it = tab_events_.find(tab_id);
-  DCHECK(it != tab_events_.end());
+  if (it == tab_events_.end())
+    return false;
+
   if (it->second == event) {
     tab_events_.erase(it);
     return true;
   }
   return false;
 }
 
 bool DataUseUITabModel::ConvertTransitionType(
     ui::PageTransition page_transition,
     DataUseTabModel::TransitionType* transition_type) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   if (!ui::PageTransitionIsMainFrame(page_transition) ||
       (((page_transition & ui::PAGE_TRANSITION_CORE_MASK) !=
         ui::PAGE_TRANSITION_RELOAD) &&
        !ui::PageTransitionIsNewNavigation(page_transition))) {
     return false;
   }
 
   switch (page_transition & ui::PAGE_TRANSITION_CORE_MASK) {
     case ui::PAGE_TRANSITION_LINK:
       if ((page_transition & ui::PAGE_TRANSITION_FROM_API) != 0) {
@@ skipping 29 matching lines @@
       }
       return false;
     default:
       return false;
   }
 }
 
 }  // namespace android
 
 }  // namespace chrome