Fixing a regression introduced with r69101, which now prevents Chrome Frame...

chrome_frame/chrome_frame_activex_base.h

 // Copyright (c) 2010 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.
 
 #ifndef CHROME_FRAME_CHROME_FRAME_ACTIVEX_BASE_H_
 #define CHROME_FRAME_CHROME_FRAME_ACTIVEX_BASE_H_
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <atlctl.h>
@@ skipping 11 matching lines @@
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_variant.h"
 #include "grit/chrome_frame_resources.h"
 #include "ceee/ie/common/ceee_util.h"
 #include "chrome/common/url_constants.h"
 #include "chrome_frame/chrome_frame_plugin.h"
 #include "chrome_frame/com_message_event.h"
 #include "chrome_frame/com_type_info_holder.h"
-#include "chrome_frame/navigation_constraints.h"
 #include "chrome_frame/simple_resource_loader.h"
 #include "chrome_frame/urlmon_url_request.h"
 #include "chrome_frame/urlmon_url_request_private.h"
 #include "chrome_frame/utils.h"
 #include "grit/generated_resources.h"
 #include "net/base/cookie_monster.h"
 
 // Include without path to make GYP build see it.
 #include "chrome_tab.h"  // NOLINT
 
@@ skipping 120 matching lines @@
   public IQuickActivateImpl<T>,
   public com_util::IProvideClassInfo2Impl<class_id,
                                           DIID_DIChromeFrameEvents>,
   public com_util::IDispatchImpl<IChromeFrame>,
   public IChromeFrameInternal,
   public IConnectionPointContainerImpl<T>,
   public ProxyDIChromeFrameEvents<T>,
   public IPropertyNotifySinkCP<T>,
   public CComCoClass<T, &class_id>,
   public CComControl<T>,
-  public ChromeFramePlugin<T>,
-  public NavigationConstraintsImpl {
+  public ChromeFramePlugin<T> {
  protected:
   typedef std::set<base::win::ScopedComPtr<IDispatch> > EventHandlers;
   typedef ChromeFrameActivexBase<T, class_id> BasePlugin;
 
  public:
   ChromeFrameActivexBase()
       : ready_state_(READYSTATE_UNINITIALIZED),
       url_fetcher_(new UrlmonUrlRequestManager()),
       failed_to_fetch_in_place_frame_(false),
       draw_sad_tab_(false),
@@ skipping 196 matching lines @@
   // ActiveX controls genereally will want to do this,
   // returning true, while true top-level documents
   // (ActiveDocument servers) will not. Your specialization
   // of this template should implement this method based on how
   // it "feels" from a security perspective. If it's hosted in another
   // scriptable document, return true, else false.
   //
   // The base implementation returns true unless we are in privileged
   // mode, in which case we always trust our container so we return false.
   bool is_frame_busting_enabled() const {
-    return !is_privileged_;
+    return !is_privileged();
   }
 
   // Needed to support PostTask.
   static bool ImplementsThreadSafeReferenceCounting() {
     return true;
   }
 
  protected:
   virtual void GetProfilePath(const std::wstring& profile_name,
                               FilePath* profile_path) {
@@ skipping 85 matching lines @@
     std::wstring wide_url = url_;
     GURL parsed_url(WideToUTF8(wide_url));
 
     // If Chrome-Frame is presently navigated to an extension page, navigating
     // the host to a url with scheme chrome-extension will fail, so we
     // point the host at http:local_host.  Note that this is NOT the URL
     // to which the host is directed.  It is only used as a temporary message
     // passing mechanism between this CF instance, and the BHO that will
     // be constructed in the new IE tab.
     if (parsed_url.SchemeIs("chrome-extension") &&
-        is_privileged_) {
+        is_privileged()) {
       const char kScheme[] = "http";
       const char kHost[] = "local_host";
 
       GURL::Replacements r;
       r.SetScheme(kScheme, url_parse::Component(0, sizeof(kScheme) -1));
       r.SetHost(kHost, url_parse::Component(0, sizeof(kHost) - 1));
       parsed_url = parsed_url.ReplaceComponents(r);
     }
 
     std::string url = base::StringPrintf(
@@ skipping 58 matching lines @@
       draw_sad_tab_ = true;
 
     ready_state_ = READYSTATE_UNINITIALIZED;
     FireOnChanged(DISPID_READYSTATE);
   }
 
   virtual void OnCloseTab(int tab_handle) {
     Fire_onclose();
   }
 
-  // NavigationConstraints overrides.
-  virtual bool IsSchemeAllowed(const GURL& url) {
-    bool allowed = NavigationConstraintsImpl::IsSchemeAllowed(url);
-    if (allowed)
-      return true;
-
-    if (is_privileged_ &&
-        (url.SchemeIs(chrome::kDataScheme) ||
-         url.SchemeIs(chrome::kExtensionScheme))) {
-      return true;
-    }
-    return false;
-  }
-
   // Overridden to take advantage of readystate prop changes and send those
   // to potential listeners.
   HRESULT FireOnChanged(DISPID dispid) {
     if (dispid == DISPID_READYSTATE) {
       Fire_onreadystatechanged(ready_state_);
     }
     return __super::FireOnChanged(dispid);
   }
 
   // IChromeFrame
@@ skipping 126 matching lines @@
   STDMETHOD(get_useChromeNetwork)(VARIANT_BOOL* use_chrome_network) {
     if (!use_chrome_network)
       return E_INVALIDARG;
 
     *use_chrome_network =
         automation_client_->use_chrome_network() ? VARIANT_TRUE : VARIANT_FALSE;
     return S_OK;
   }
 
   STDMETHOD(put_useChromeNetwork)(VARIANT_BOOL use_chrome_network) {
-    if (!is_privileged_) {
+    if (!is_privileged()) {
       DLOG(ERROR) << "Attempt to set useChromeNetwork in non-privileged mode";
       return E_ACCESSDENIED;
     }
 
     automation_client_->set_use_chrome_network(
         (VARIANT_FALSE != use_chrome_network));
     return S_OK;
   }
 
   // Posts a message to the chrome frame.
@@ skipping 76 matching lines @@
     }
 
     *version = SysAllocString(automation_client_->GetVersion().c_str());
     return S_OK;
   }
 
   STDMETHOD(postPrivateMessage)(BSTR message, BSTR origin, BSTR target) {
     if (NULL == message)
       return E_INVALIDARG;
 
-    if (!is_privileged_) {
+    if (!is_privileged()) {
       DLOG(ERROR) << "Attempt to postPrivateMessage in non-privileged mode";
       return E_ACCESSDENIED;
     }
 
     DCHECK(automation_client_.get());
     std::string utf8_message, utf8_origin, utf8_target;
     WideToUTF8(message, ::SysStringLen(message), &utf8_message);
     WideToUTF8(origin, ::SysStringLen(origin), &utf8_origin);
     WideToUTF8(target, ::SysStringLen(target), &utf8_target);
 
     if (!automation_client_->ForwardMessageFromExternalHost(utf8_message,
                                                             utf8_origin,
                                                             utf8_target)) {
       Error(L"Failed to post message to chrome frame");
       return E_FAIL;
     }
 
     return S_OK;
   }
 
   STDMETHOD(installExtension)(BSTR crx_path) {
     DCHECK(automation_client_.get());
 
     if (NULL == crx_path) {
       NOTREACHED();
       return E_INVALIDARG;
     }
 
-    if (!is_privileged_) {
+    if (!is_privileged()) {
       DLOG(ERROR) << "Attempt to installExtension in non-privileged mode";
       return E_ACCESSDENIED;
     }
 
     FilePath::StringType crx_path_str(crx_path);
     FilePath crx_file_path(crx_path_str);
 
     automation_client_->InstallExtension(crx_file_path, NULL);
     return S_OK;
   }
 
   STDMETHOD(loadExtension)(BSTR path) {
     DCHECK(automation_client_.get());
 
     if (NULL == path) {
       NOTREACHED();
       return E_INVALIDARG;
     }
 
-    if (!is_privileged_) {
+    if (!is_privileged()) {
       DLOG(ERROR) << "Attempt to loadExtension in non-privileged mode";
       return E_ACCESSDENIED;
     }
 
     FilePath::StringType path_str(path);
     FilePath file_path(path_str);
 
     automation_client_->LoadExpandedExtension(file_path, NULL);
     return S_OK;
   }
 
   STDMETHOD(getEnabledExtensions)() {
     DCHECK(automation_client_.get());
 
-    if (!is_privileged_) {
+    if (!is_privileged()) {
       DLOG(ERROR) << "Attempt to getEnabledExtensions in non-privileged mode";
       return E_ACCESSDENIED;
     }
 
     automation_client_->GetEnabledExtensions(NULL);
     return S_OK;
   }
 
   STDMETHOD(getSessionId)(int* session_id) {
     DCHECK(automation_client_.get());
     DCHECK(session_id);
 
-    if (!is_privileged_) {
+    if (!is_privileged()) {
       DLOG(ERROR) << "Attempt to getSessionId in non-privileged mode";
       return E_ACCESSDENIED;
     }
 
     *session_id = automation_client_->GetSessionId();
     return (*session_id) == -1 ? S_FALSE : S_OK;
   }
 
   STDMETHOD(registerBhoIfNeeded)() {
     return E_NOTIMPL;
@@ skipping 13 matching lines @@
     } else if (LowerCaseEqualsASCII(event_type, event_type_end, "load")) {
       *handlers = &onload_;
     } else if (LowerCaseEqualsASCII(event_type, event_type_end, "loaderror")) {
       *handlers = &onloaderror_;
     } else if (LowerCaseEqualsASCII(event_type, event_type_end,
                                     "readystatechanged")) {
       *handlers = &onreadystatechanged_;
     } else if (LowerCaseEqualsASCII(event_type, event_type_end,
                                     "privatemessage")) {
       // This event handler is only available in privileged mode.
-      if (is_privileged_) {
+      if (is_privileged()) {
         *handlers = &onprivatemessage_;
       } else {
         Error("Event type 'privatemessage' is privileged");
         hr = E_ACCESSDENIED;
       }
     } else if (LowerCaseEqualsASCII(event_type, event_type_end,
                                     "extensionready")) {
       // This event handler is only available in privileged mode.
-      if (is_privileged_) {
+      if (is_privileged()) {
         *handlers = &onextensionready_;
       } else {
         Error("Event type 'extensionready' is privileged");
         hr = E_ACCESSDENIED;
       }
     } else {
       Error(base::StringPrintf(
           "Event type '%ls' not found", event_type).c_str());
       hr = E_INVALIDARG;
     }
@@ skipping 323 matching lines @@
   EventHandlers onextensionready_;
 
   // Handle network requests when host network stack is used. Passed to the
   // automation client on initialization.
   scoped_ptr<UrlmonUrlRequestManager> url_fetcher_;
 
   HINSTANCE prev_resource_instance_;
 };
 
 #endif  // CHROME_FRAME_CHROME_FRAME_ACTIVEX_BASE_H_