Removing references to Off the Record from MediaRouter

chrome/browser/ui/webui/media_router/media_router_ui.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/ui/webui/media_router/media_router_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 351 matching lines @@
     issues_observer_.reset(new UIIssuesObserver(router_, this));
   issues_observer_->RegisterObserver();
 }
 
 bool MediaRouterUI::CreateRoute(const MediaSink::Id& sink_id,
                                 MediaCastMode cast_mode) {
   MediaSource::Id source_id;
   GURL origin;
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   base::TimeDelta timeout;
-  bool off_the_record;
+  bool incognito;
   if (!SetRouteParameters(sink_id, cast_mode, &source_id, &origin,
-                          &route_response_callbacks, &timeout,
-                          &off_the_record)) {
+                          &route_response_callbacks, &timeout, &incognito)) {
     SendIssueForUnableToCast(cast_mode);
     return false;
   }
   router_->CreateRoute(source_id, sink_id, origin, initiator_,
-                       route_response_callbacks, timeout, off_the_record);
+                       route_response_callbacks, timeout, incognito);
   return true;
 }
 
 bool MediaRouterUI::SetRouteParameters(
     const MediaSink::Id& sink_id,
     MediaCastMode cast_mode,
     MediaSource::Id* source_id,
     GURL* origin,
     std::vector<MediaRouteResponseCallback>* route_response_callbacks,
     base::TimeDelta* timeout,
-    bool* off_the_record) {
+    bool* incognito) {
   DCHECK(query_result_manager_.get());
   DCHECK(initiator_);
 
   // Note that there is a rarely-encountered bug, where the MediaCastMode to
   // MediaSource mapping could have been updated, between when the user clicked
   // on the UI to start a create route request, and when this function is
   // called. However, since the user does not have visibility into the
   // MediaSource, and that it occurs very rarely in practice, we leave it as-is
   // for now.
   MediaSource source = query_result_manager_->GetSourceForCastMode(cast_mode);
@@ skipping 46 matching lines @@
           base::Bind(&MediaRouterUI::HandleCreateSessionRequestRouteResponse,
                      weak_factory_.GetWeakPtr()));
     } else if (presentation_service_delegate_) {
       route_response_callbacks->push_back(
           base::Bind(&PresentationServiceDelegateImpl::OnRouteResponse,
                      presentation_service_delegate_, *presentation_request_));
     }
   }
 
   *timeout = GetRouteRequestTimeout(cast_mode);
-  *off_the_record = Profile::FromWebUI(web_ui())->IsOffTheRecord();
+  *incognito = Profile::FromWebUI(web_ui())->IsOffTheRecord();
 
   return true;
 }
 
 bool MediaRouterUI::ConnectRoute(const MediaSink::Id& sink_id,
                                  const MediaRoute::Id& route_id) {
   MediaSource::Id source_id;
   GURL origin;
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   base::TimeDelta timeout;
-  bool off_the_record;
+  bool incognito;
   if (!SetRouteParameters(sink_id, MediaCastMode::DEFAULT, &source_id, &origin,
-                          &route_response_callbacks, &timeout,
-                          &off_the_record)) {
+                          &route_response_callbacks, &timeout, &incognito)) {
     SendIssueForUnableToCast(MediaCastMode::DEFAULT);
     return false;
   }
   router_->ConnectRouteByRouteId(source_id, route_id, origin, initiator_,
-                                 route_response_callbacks, timeout,
-                                 off_the_record);
+                                 route_response_callbacks, timeout, incognito);
   return true;
 }
 
 void MediaRouterUI::CloseRoute(const MediaRoute::Id& route_id) {
   router_->TerminateRoute(route_id);
 }
 
 void MediaRouterUI::AddIssue(const Issue& issue) { router_->AddIssue(issue); }
 
 void MediaRouterUI::ClearIssue(const std::string& issue_id) {
@@ skipping 105 matching lines @@
 void MediaRouterUI::OnSearchSinkResponseReceived(
     MediaCastMode cast_mode,
     const MediaSink::Id& found_sink_id) {
   DVLOG(1) << "OnSearchSinkResponseReceived";
   handler_->ReturnSearchResult(found_sink_id);
 
   MediaSource::Id source_id;
   GURL origin;
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   base::TimeDelta timeout;
-  bool off_the_record;
+  bool incognito;
   if (!SetRouteParameters(found_sink_id, cast_mode, &source_id, &origin,
-                          &route_response_callbacks, &timeout,
-                          &off_the_record)) {
+                          &route_response_callbacks, &timeout, &incognito)) {
     SendIssueForUnableToCast(cast_mode);
     return;
   }
   router_->CreateRoute(source_id, found_sink_id, origin, initiator_,
-                       route_response_callbacks, timeout, off_the_record);
+                       route_response_callbacks, timeout, incognito);
 }
 
 void MediaRouterUI::SendIssueForRouteTimeout(
     MediaCastMode cast_mode,
     const base::string16& presentation_request_source_name) {
   std::string issue_title;
   switch (cast_mode) {
     case DEFAULT:
       DLOG_IF(ERROR, presentation_request_source_name.empty())
           << "Empty presentation request source name.";
@@ skipping 79 matching lines @@
         base::Time::Now() - start_time_);
     start_time_ = base::Time();
   }
 }
 
 void MediaRouterUI::UpdateMaxDialogHeight(int height) {
   handler_->UpdateMaxDialogHeight(height);
 }
 
 }  // namespace media_router