Prevent incognito windows from opening when incognito mode is disabled.

chrome/browser/extensions/extension_tabs_module.cc

 // Copyright (c) 2011 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/extensions/extension_tabs_module.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 232 matching lines @@
            (*browser)->profile() == incognito_profile) &&
           (*browser)->window()) {
         static_cast<ListValue*>(result_.get())->
           Append(ExtensionTabUtil::CreateWindowValue(*browser, populate_tabs));
       }
   }
 
   return true;
 }
 
+bool CreateWindowFunction::ShouldOpenIncognitoWindow(
+    const base::DictionaryValue* args,
+    std::vector<GURL>* urls,
+    bool* is_error) {
+  *is_error = false;
+  const IncognitoModePrefs::Availability incognito_availability =
+      IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
+  bool incognito = false;
+  if (args && args->HasKey(keys::kIncognitoKey)) {
+    EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kIncognitoKey,
+                                                 &incognito));
+    if (incognito && incognito_availability == IncognitoModePrefs::DISABLED) {
+      error_ = keys::kIncognitoModeIsDisabled;
+      *is_error = true;
+      return false;
+    }
+    if (!incognito && incognito_availability == IncognitoModePrefs::FORCED) {
+      error_ = keys::kIncognitoModeIsForced;
+      *is_error = true;
+      return false;
+    }
+  } else if (incognito_availability == IncognitoModePrefs::FORCED) {
+    // If incognito argument is not specified explicitly, we default to
+    // incognito when forced so by policy.
+    incognito = true;
+  }
+
+  // If we are opening an incognito window.
+  if (incognito) {
+    std::string first_url_erased;
+    // Guest session is an exception as it always opens in incognito mode.
+    for (size_t i = 0; i < urls->size();) {
+      if (browser::IsURLAllowedInIncognito((*urls)[i]) &&
+          !Profile::IsGuestSession()) {
+        if (first_url_erased.empty())
+          first_url_erased = (*urls)[i].spec();
+        urls->erase(urls->begin() + i);
+      } else {
+        i++;
+      }
+    }
+    if (urls->empty() && !first_url_erased.empty()) {
+      error_ = ExtensionErrorUtils::FormatErrorMessage(
+          keys::kURLsNotAllowedInIncognitoError, first_url_erased);
+      *is_error = true;
+      return false;
+    }
+  }
+  return incognito;
+}
+
 bool CreateWindowFunction::RunImpl() {
   DictionaryValue* args = NULL;
   std::vector<GURL> urls;
   TabContentsWrapper* contents = NULL;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   // Look for optional url.
   if (args) {
@@ skipping 82 matching lines @@
 #else
   popup_bounds = window_bounds;  // Use window size as default for popups
 #endif
 
   Profile* window_profile = profile();
   Browser::Type window_type = Browser::TYPE_TABBED;
   bool focused = true;
   bool saw_focus_key = false;
   std::string extension_id;
 
+  // Decide whether we are opening a normal window or an incognito window.
+  bool is_error;
+  bool open_incognito_window = ShouldOpenIncognitoWindow(args, &urls,
+                                                         &is_error);
+  if (is_error) {
+    // error_ member variable is set inside of ShouldOpenIncognitoWindow.
+    return false;
+  }
+  if (open_incognito_window) {
+    window_profile = window_profile->GetOffTheRecordProfile();
+  }
+
   if (args) {
     // Any part of the bounds can optionally be set by the caller.
     int bounds_val;
     if (args->HasKey(keys::kLeftKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kLeftKey,
                                                    &bounds_val));
       window_bounds.set_x(bounds_val);
       popup_bounds.set_x(bounds_val);
       panel_bounds.set_x(bounds_val);
     }
@@ skipping 15 matching lines @@
     }
 
     if (args->HasKey(keys::kHeightKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kHeightKey,
                                                    &bounds_val));
       window_bounds.set_height(bounds_val);
       popup_bounds.set_height(bounds_val);
       panel_bounds.set_height(bounds_val);
     }
 
-    bool incognito = false;
-    if (args->HasKey(keys::kIncognitoKey)) {
-      EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kIncognitoKey,
-                                                   &incognito));
-      if (IncognitoModePrefs::GetAvailability(profile_->GetPrefs()) ==
-          IncognitoModePrefs::DISABLED) {
-        error_ = keys::kIncognitoModeIsDisabled;
-        return false;
-      }
-
-      if (incognito) {
-        std::string first_url_erased;
-        // Guest session is an exception as it always opens in incognito mode.
-        for (size_t i = 0; i < urls.size();) {
-          if (browser::IsURLAllowedInIncognito(urls[i]) &&
-              !Profile::IsGuestSession()) {
-            if (first_url_erased.empty())
-              first_url_erased = urls[i].spec();
-            urls.erase(urls.begin() + i);
-          } else {
-            i++;
-          }
-        }
-        if (urls.empty() && !first_url_erased.empty()) {
-          error_ = ExtensionErrorUtils::FormatErrorMessage(
-              keys::kURLsNotAllowedInIncognitoError, first_url_erased);
-          return false;
-        }
-        window_profile = window_profile->GetOffTheRecordProfile();
-      }
-    }
-
     if (args->HasKey(keys::kFocusedKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kFocusedKey,
                                                    &focused));
       saw_focus_key = true;
     }
 
     std::string type_str;
     if (args->HasKey(keys::kWindowTypeKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kWindowTypeKey,
                                                   &type_str));
@@ skipping 1106 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }