implement user agent override option.

ios/web/navigation/navigation_manager_impl.mm

 // Copyright 2013 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.
 
 #import "ios/web/navigation/navigation_manager_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 26 matching lines @@
   return existing_url.EqualsIgnoringRef(new_url);
 }
 
 }  // anonymous namespace
 
 namespace web {
 
 NavigationManager::WebLoadParams::WebLoadParams(const GURL& url)
     : url(url),
       transition_type(ui::PAGE_TRANSITION_LINK),
+      user_agent_override_option(UserAgentOverrideOption::INHERIT),
       is_renderer_initiated(false),
       post_data(nil) {}
 
 NavigationManager::WebLoadParams::~WebLoadParams() {}
 
 NavigationManager::WebLoadParams::WebLoadParams(const WebLoadParams& other)
     : url(other.url),
       referrer(other.referrer),
       transition_type(other.transition_type),
+      user_agent_override_option(other.user_agent_override_option),
       is_renderer_initiated(other.is_renderer_initiated),
       extra_headers([other.extra_headers copy]),
       post_data([other.post_data copy]) {}
 
 NavigationManager::WebLoadParams& NavigationManager::WebLoadParams::operator=(
     const WebLoadParams& other) {
   url = other.url;
   referrer = other.referrer;
   is_renderer_initiated = other.is_renderer_initiated;
   transition_type = other.transition_type;
+  user_agent_override_option = other.user_agent_override_option;
   extra_headers.reset([other.extra_headers copy]);
   post_data.reset([other.post_data copy]);
 
   return *this;
 }
 
 NavigationManagerImpl::NavigationManagerImpl()
-    : override_desktop_user_agent_for_next_pending_item_(false),
-      delegate_(nullptr),
-      browser_state_(nullptr),
-      facade_delegate_(nullptr) {}
+    : delegate_(nullptr), browser_state_(nullptr), facade_delegate_(nullptr) {}
 
 NavigationManagerImpl::~NavigationManagerImpl() {
   // The facade layer should be deleted before this object.
   DCHECK(!facade_delegate_);
 
   [session_controller_ setNavigationManager:nullptr];
 }
 
 void NavigationManagerImpl::SetDelegate(NavigationManagerDelegate* delegate) {
   delegate_ = delegate;
@@ skipping 80 matching lines @@
                                     ui::PageTransition type) {
   WebState::OpenURLParams params(url, referrer,
                                  WindowOpenDisposition::CURRENT_TAB, type, NO);
   delegate_->GetWebState()->OpenURL(params);
 }
 
 void NavigationManagerImpl::AddPendingItem(
     const GURL& url,
     const web::Referrer& referrer,
     ui::PageTransition navigation_type,
-    NavigationInitiationType initiation_type) {
+    NavigationInitiationType initiation_type,
+    UserAgentOverrideOption user_agent_override_option) {
   [session_controller_ addPendingItem:url
                              referrer:referrer
                            transition:navigation_type
                        initiationType:initiation_type];
 
   // Set the user agent type for web URLs.
   NavigationItem* pending_item = GetPendingItem();
   if (!pending_item)
     return;
 
-  // |override_desktop_user_agent_for_next_pending_item_| must be false if
-  // |pending_item|'s UserAgentType is NONE, as requesting a desktop user
-  // agent should be disabled for app-specific URLs.
+  // |user_agent_override_option| must be INHERIT if |pending_item|'s
+  // UserAgentType is NONE, as requesting a desktop or mobile user agent should
+  // be disabled for app-specific URLs.
   DCHECK(pending_item->GetUserAgentType() != UserAgentType::NONE ||
-         !override_desktop_user_agent_for_next_pending_item_);
+         user_agent_override_option == UserAgentOverrideOption::INHERIT);
 
   // Newly created pending items are created with UserAgentType::NONE for native
   // pages or UserAgentType::MOBILE for non-native pages.  If the pending item's
-  // URL is non-native, check whether it should be created with
-  // UserAgentType::DESKTOP.
+  // URL is non-native, check which user agent type it should be created with
+  // based on |user_agent_override_option|.
   DCHECK_NE(UserAgentType::DESKTOP, pending_item->GetUserAgentType());
-  if (pending_item->GetUserAgentType() != UserAgentType::NONE) {
-    bool use_desktop_user_agent =
-        override_desktop_user_agent_for_next_pending_item_;
-    if (!use_desktop_user_agent) {
-      // If the flag is not set, propagate the last non-native item's
-      // UserAgentType.
+  if (pending_item->GetUserAgentType() == UserAgentType::NONE)
+    return;
+
+  switch (user_agent_override_option) {
+    case UserAgentOverrideOption::DESKTOP:
+      pending_item->SetUserAgentType(UserAgentType::DESKTOP);
+      break;
+    case UserAgentOverrideOption::MOBILE:
+      pending_item->SetUserAgentType(UserAgentType::MOBILE);
+      break;
+    case UserAgentOverrideOption::INHERIT: {
+      // If INHERIT, propagate the last non-native item's UserAgentType.
       NavigationItem* last_non_native_item =
           GetLastCommittedNonAppSpecificItem();
       DCHECK(!last_non_native_item ||
              last_non_native_item->GetUserAgentType() != UserAgentType::NONE);
-      use_desktop_user_agent =
-          last_non_native_item &&
-          last_non_native_item->GetUserAgentType() == UserAgentType::DESKTOP;
+      if (last_non_native_item) {
+        pending_item->SetUserAgentType(
+            last_non_native_item->GetUserAgentType());
+      }
+      break;
     }
-    if (use_desktop_user_agent)
-      pending_item->SetUserAgentType(UserAgentType::DESKTOP);
+    default:

[Eugene But (OOO till 7-30), 2017/03/30 19:21:24]

There is no need for default, which prevents compiler warning about unhandled
cases

[liaoyuke, 2017/03/30 19:56:25]

I see, but the original intention of default is to add NOTREACHED() to prevent
surprises, is there a way to keep NOTREACHED() without default?

[Eugene But (OOO till 7-30), 2017/03/30 20:42:31]

This NOTREACHED will never be executed. NOTREACHED is debug only so it can
happen only on local builds. If a new item is added to UserAgentOverrideOption
and not handled in this switch case then the local build will not even compile.
So there should be no "surprises" :)

+      NOTREACHED();
   }
-  override_desktop_user_agent_for_next_pending_item_ = false;
 }
 
 NavigationItemList NavigationManagerImpl::GetItems() const {
   return CreateNavigationItemList([session_controller_ items]);
 }
 
 BrowserState* NavigationManagerImpl::GetBrowserState() const {
   return browser_state_;
 }
 
@@ skipping 211 matching lines @@
     // Result may be out of bounds, so stop trying to skip redirect items and
     // simply add the remainder.
     result += offset;
     if (result < 0 /* overflow */)
       result = INT_MAX;
   }
 
   return result;
 }
 
-void NavigationManagerImpl::OverrideDesktopUserAgentForNextPendingItem() {
-  NavigationItem* pending_item = GetPendingItem();
-  if (pending_item) {
-    // The desktop user agent cannot be used for a pending navigation to an
-    // app-specific URL.
-    DCHECK_NE(pending_item->GetUserAgentType(), UserAgentType::NONE);
-    pending_item->SetUserAgentType(UserAgentType::DESKTOP);
-  } else {
-    override_desktop_user_agent_for_next_pending_item_ = true;
-  }
-}
-
 bool NavigationManagerImpl::IsRedirectItemAtIndex(int index) const {
   DCHECK_GE(index, 0);
   DCHECK_LT(index, GetItemCount());
   ui::PageTransition transition = GetItemAtIndex(index)->GetTransitionType();
   return transition & ui::PAGE_TRANSITION_IS_REDIRECT_MASK;
 }
 
 NavigationItem* NavigationManagerImpl::GetLastCommittedNonAppSpecificItem()
     const {
   int index = GetLastCommittedItemIndex();
   if (index == -1)
     return nullptr;
   WebClient* client = GetWebClient();
   const ScopedNavigationItemImplList& items = [session_controller_ items];
   while (index >= 0) {
     NavigationItem* item = items[index--].get();
     if (!client->IsAppSpecificURL(item->GetVirtualURL()))
       return item;
   }
   return nullptr;
 }
 
 }  // namespace web