Removing references to Off the Record from MediaRouter

chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 97 matching lines @@
 }
 
 interfaces::MediaRoutePtr CreateMojoRoute() {
   interfaces::MediaRoutePtr route = interfaces::MediaRoute::New();
   route->media_source = kSource;
   route->media_sink_id = kSinkId;
   route->media_route_id = kRouteId;
   route->description = kDescription;
   route->is_local = true;
   route->for_display = true;
-  route->off_the_record = false;
+  route->incognito = false;
   return route;
 }
 
 }  // namespace
 
 class RouteResponseCallbackHandler {
  public:
   void Invoke(const RouteRequestResult& result) {
     DoInvoke(result.route(), result.presentation_id(), result.error(),
              result.result_code());
@@ skipping 103 matching lines @@
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
                           mojo::String(kOrigin), kInvalidTabId, _, _, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& sink,
              const mojo::String& presentation_id, const mojo::String& origin,
-             int tab_id, int64_t timeout_millis, bool off_the_record,
+             int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(CreateMojoRoute(), mojo::String(),
                    interfaces::RouteRequestResultCode::OK);
           }));
 
   base::RunLoop run_loop;
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->CreateRoute(
       kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
 }
 
-TEST_F(MediaRouterMojoImplTest, CreateOffTheRecordRoute) {
+TEST_F(MediaRouterMojoImplTest, CreateIncognitoRoute) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
-  expected_route.set_off_the_record(true);
+  expected_route.set_incognito(true);
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
                           mojo::String(kOrigin), kInvalidTabId, _, _, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& sink,
              const mojo::String& presentation_id, const mojo::String& origin,
-             int tab_id, int64_t timeout_millis, bool off_the_record,
+             int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             interfaces::MediaRoutePtr route = CreateMojoRoute();
             route->custom_controller_path = "custom/controller/path";
-            route->off_the_record = true;
+            route->incognito = true;
             cb.Run(std::move(route), mojo::String(),
                    interfaces::RouteRequestResultCode::OK);
           }));
 
   base::RunLoop run_loop;
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->CreateRoute(
       kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, CreateRouteFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
       CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
                   mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, _, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& sink,
              const mojo::String& presentation_id, const mojo::String& origin,
-             int tab_id, int64_t timeout_millis, bool off_the_record,
+             int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError),
                    interfaces::RouteRequestResultCode::TIMED_OUT);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler,
               DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->CreateRoute(
       kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
 }
 
-TEST_F(MediaRouterMojoImplTest, CreateRouteOffTheRecordMismatchFails) {
+TEST_F(MediaRouterMojoImplTest, CreateRouteIncognitoMismatchFails) {
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
                           mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis,
                           true, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& sink,
              const mojo::String& presentation_id, const mojo::String& origin,
-             int tab_id, int64_t timeout_millis, bool off_the_record,
+             int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             cb.Run(CreateMojoRoute(), mojo::String(),
                    interfaces::RouteRequestResultCode::OK);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
-  std::string error(
-      "Mismatch in off the record status: request = 1, response = 0");
+  std::string error("Mismatch in incognito status: request = 1, response = 0");
   EXPECT_CALL(handler, DoInvoke(nullptr, "", error,
-                                RouteRequestResult::OFF_THE_RECORD_MISMATCH))
+                                RouteRequestResult::INCOGNITO_MISMATCH))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->CreateRoute(
       kSource, kSinkId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
 }
 
-TEST_F(MediaRouterMojoImplTest, OffTheRecordRoutesTerminatedOnProfileShutdown) {
+TEST_F(MediaRouterMojoImplTest, IncognitoRoutesTerminatedOnProfileShutdown) {
   interfaces::MediaRoutePtr route = CreateMojoRoute();
-  route->off_the_record = true;
+  route->incognito = true;
 
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
                           mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis,
                           true, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& sink,
              const mojo::String& presentation_id, const mojo::String& origin,
-             int tab_id, int64_t timeout_millis, bool off_the_record,
+             int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
             interfaces::MediaRoutePtr route = CreateMojoRoute();
-            route->off_the_record = true;
+            route->incognito = true;
             cb.Run(std::move(route), mojo::String(),
                    interfaces::RouteRequestResultCode::OK);
           }));
   base::RunLoop run_loop;
   router()->CreateRoute(kSource, kSinkId, GURL(kOrigin), nullptr,
                         std::vector<MediaRouteResponseCallback>(),
                         base::TimeDelta::FromMilliseconds(kTimeoutMillis),
                         true);
   mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
   router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
                             mojo::Array<mojo::String>());
 
   // TODO(mfoltz): Where possible, convert other tests to use RunUntilIdle
   // instead of manually calling Run/Quit on the run loop.
   run_loop.RunUntilIdle();
 
   EXPECT_CALL(mock_media_route_provider_,
               TerminateRoute(mojo::String(kRouteId), _))
       .WillOnce(Invoke([](
           const mojo::String& route_id,
           const interfaces::MediaRouteProvider::TerminateRouteCallback& cb) {
          cb.Run(mojo::String(), interfaces::RouteRequestResultCode::OK);
        }));
 
   base::RunLoop run_loop2;
-  router()->OnOffTheRecordProfileShutdown();
+  router()->OnIncognitoProfileShutdown();
   run_loop2.RunUntilIdle();
 }
 
 TEST_F(MediaRouterMojoImplTest, JoinRoute) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
 
   interfaces::MediaRoutePtr route = CreateMojoRoute();
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
   mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
   router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
                             mojo::Array<mojo::String>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(
       mock_media_route_provider_,
       JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                 mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, _, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& presentation_id,
           const mojo::String& origin, int tab_id, int64_t timeout_millis,
-          bool off_the_record,
+          bool incognito,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), mojo::String(),
                interfaces::RouteRequestResultCode::OK);
       }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
@@ skipping 30 matching lines @@
                             mojo::Array<mojo::String>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   EXPECT_CALL(
       mock_media_route_provider_,
       JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                 mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, _, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& presentation_id,
              const mojo::String& origin, int tab_id, int64_t timeout_millis,
-             bool off_the_record,
+             bool incognito,
              const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
             cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError),
                    interfaces::RouteRequestResultCode::TIMED_OUT);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler,
               DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
 }
 
-TEST_F(MediaRouterMojoImplTest, JoinRouteOffTheRecordMismatchFails) {
+TEST_F(MediaRouterMojoImplTest, JoinRouteIncognitoMismatchFails) {
   interfaces::MediaRoutePtr route = CreateMojoRoute();
 
   // Make sure the MR has received an update with the route, so it knows there
   // is a route to join.
   mojo::Array<interfaces::MediaRoutePtr> mojo_routes(1);
   mojo_routes[0] = route->Clone();
   router()->OnRoutesUpdated(std::move(mojo_routes), mojo::String(),
                             mojo::Array<mojo::String>());
   EXPECT_TRUE(router()->HasJoinableRoute());
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(
       mock_media_route_provider_,
       JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                 mojo::String(kOrigin), kInvalidTabId, kTimeoutMillis, true, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& presentation_id,
           const mojo::String& origin, int tab_id, int64_t timeout_millis,
-          bool off_the_record,
+          bool incognito,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), mojo::String(),
                interfaces::RouteRequestResultCode::OK);
       }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
-  std::string error(
-      "Mismatch in off the record status: request = 1, response = 0");
+  std::string error("Mismatch in incognito status: request = 1, response = 0");
   EXPECT_CALL(handler, DoInvoke(nullptr, "", error,
-                                RouteRequestResult::OFF_THE_RECORD_MISMATCH))
+                                RouteRequestResult::INCOGNITO_MISMATCH))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->JoinRoute(kSource, kPresentationId, GURL(kOrigin), nullptr,
                       route_response_callbacks,
                       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteId) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
-  expected_route.set_off_the_record(false);
+  expected_route.set_incognito(false);
   interfaces::MediaRoutePtr route = CreateMojoRoute();
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(
       mock_media_route_provider_,
       ConnectRouteByRouteId(mojo::String(kSource), mojo::String(kRouteId), _,
                             mojo::String(kOrigin), kInvalidTabId,
                             kTimeoutMillis, false, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& route_id,
           const mojo::String& presentation_id, const mojo::String& origin,
-          int tab_id, int64_t timeout_millis, bool off_the_record,
+          int tab_id, int64_t timeout_millis, bool incognito,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), mojo::String(),
                interfaces::RouteRequestResultCode::OK);
       }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler, DoInvoke(Pointee(Equals(expected_route)), Not(""), "",
                                 RouteRequestResult::OK))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(
       kSource, kRouteId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), false);
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, ConnectRouteByRouteIdFails) {
   EXPECT_CALL(
       mock_media_route_provider_,
       ConnectRouteByRouteId(mojo::String(kSource), mojo::String(kRouteId), _,
                             mojo::String(kOrigin), kInvalidTabId,
                             kTimeoutMillis, true, _))
       .WillOnce(Invoke(
           [](const mojo::String& source, const mojo::String& route_id,
              const mojo::String& presentation_id, const mojo::String& origin,
-             int tab_id, int64_t timeout_millis, bool off_the_record,
+             int tab_id, int64_t timeout_millis, bool incognito,
              const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
             cb.Run(interfaces::MediaRoutePtr(), mojo::String(kError),
                    interfaces::RouteRequestResultCode::TIMED_OUT);
           }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
   EXPECT_CALL(handler,
               DoInvoke(nullptr, "", kError, RouteRequestResult::TIMED_OUT))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(
       kSource, kRouteId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
 }
 
-TEST_F(MediaRouterMojoImplTest, ConnectRouteByIdOffTheRecordMismatchFails) {
+TEST_F(MediaRouterMojoImplTest, ConnectRouteByIdIncognitoMismatchFails) {
   interfaces::MediaRoutePtr route = CreateMojoRoute();
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(
       mock_media_route_provider_,
       ConnectRouteByRouteId(mojo::String(kSource), mojo::String(kRouteId), _,
                             mojo::String(kOrigin), kInvalidTabId,
                             kTimeoutMillis, true, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& route_id,
           const mojo::String& presentation_id, const mojo::String& origin,
-          int tab_id, int64_t timeout_millis, bool off_the_record,
+          int tab_id, int64_t timeout_millis, bool incognito,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
         cb.Run(std::move(route), mojo::String(),
                interfaces::RouteRequestResultCode::OK);
       }));
 
   RouteResponseCallbackHandler handler;
   base::RunLoop run_loop;
-  std::string error(
-      "Mismatch in off the record status: request = 1, response = 0");
+  std::string error("Mismatch in incognito status: request = 1, response = 0");
   EXPECT_CALL(handler, DoInvoke(nullptr, "", error,
-                                RouteRequestResult::OFF_THE_RECORD_MISMATCH))
+                                RouteRequestResult::INCOGNITO_MISMATCH))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &RouteResponseCallbackHandler::Invoke, base::Unretained(&handler)));
   router()->ConnectRouteByRouteId(
       kSource, kRouteId, GURL(kOrigin), nullptr, route_response_callbacks,
       base::TimeDelta::FromMilliseconds(kTimeoutMillis), true);
   run_loop.Run();
 }
 
@@ skipping 276 matching lines @@
   EXPECT_EQ(observer_captured, &different_routes_observer);
   router()->RegisterMediaRoutesObserver(&routes_observer);
   router()->RegisterMediaRoutesObserver(&extra_routes_observer);
   router()->RegisterMediaRoutesObserver(&different_routes_observer);
 
   std::vector<MediaRoute> expected_routes;
   expected_routes.push_back(MediaRoute(kRouteId, media_source, kSinkId,
                                        kDescription, false, "", false));
   MediaRoute incognito_expected_route(kRouteId2, media_source, kSinkId,
                                       kDescription, false, "", false);
-  incognito_expected_route.set_off_the_record(true);
+  incognito_expected_route.set_incognito(true);
   expected_routes.push_back(incognito_expected_route);
   std::vector<MediaRoute::Id> expected_joinable_route_ids;
   expected_joinable_route_ids.push_back(kJoinableRouteId);
   expected_joinable_route_ids.push_back(kJoinableRouteId2);
 
   mojo::Array<mojo::String> mojo_joinable_routes(2);
   mojo_joinable_routes[0] = kJoinableRouteId;
   mojo_joinable_routes[1] = kJoinableRouteId2;
 
   mojo::Array<interfaces::MediaRoutePtr> mojo_routes(2);
   mojo_routes[0] = CreateMojoRoute();
   mojo_routes[1] = CreateMojoRoute();
   mojo_routes[1]->media_route_id = kRouteId2;
-  mojo_routes[1]->off_the_record = true;
+  mojo_routes[1]->incognito = true;
 
   EXPECT_CALL(routes_observer, OnRoutesUpdated(SequenceEquals(expected_routes),
                                                expected_joinable_route_ids));
   EXPECT_CALL(extra_routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes),
                               expected_joinable_route_ids));
   EXPECT_CALL(different_routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes),
                               expected_joinable_route_ids))
       .Times(0);
@@ skipping 645 matching lines @@
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(mojo::String(MediaSourceForDesktop().id())))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
 }  // namespace media_router