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

chrome_frame/chrome_frame_npapi.cc

 // 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.
 
 #include "chrome_frame/chrome_frame_npapi.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_split.h"
@@ skipping 212 matching lines @@
       if (argv[i][0] != '\0')
         base::SplitString(argv[i], ',', &functions_enabled_);
     } else if (LowerCaseEqualsASCII(argn[i], kPluginUseChromeNetwork)) {
       chrome_network_arg_set = true;
       chrome_network_arg = atoi(argv[i]) ? true : false;
     }
   }
 
   // Is the privileged mode requested?
   if (wants_privileged) {
-    is_privileged_ = IsFireFoxPrivilegedInvocation(instance);
-    if (!is_privileged_) {
+    set_is_privileged(IsFireFoxPrivilegedInvocation(instance));
+    if (!is_privileged()) {
       DLOG(WARNING) << "Privileged mode requested in non-privileged context";
     }
   }
 
   std::wstring extra_arguments;
   std::wstring profile_name(GetHostProcessName(false));
-  if (is_privileged_) {
+  if (is_privileged()) {
     // Process any privileged mode-only arguments we were handed.
     if (onprivatemessage_arg)
       onprivatemessage_handler_ = JavascriptToNPObject(onprivatemessage_arg);
 
     if (chrome_extra_arguments_arg)
       extra_arguments = UTF8ToWide(chrome_extra_arguments_arg);
 
     if (chrome_profile_name_arg)
       profile_name = UTF8ToWide(chrome_profile_name_arg);
 
     if (chrome_network_arg_set)
       automation_client_->set_use_chrome_network(chrome_network_arg);
   }
 
   static const wchar_t kHandleTopLevelRequests[] = L"HandleTopLevelRequests";
   bool top_level_requests = GetConfigBool(true, kHandleTopLevelRequests);
   automation_client_->set_handle_top_level_requests(top_level_requests);
   automation_client_->set_route_all_top_level_navigations(true);
 
   // Setup Url fetcher.
   url_fetcher_.set_NPPInstance(instance_);
-  url_fetcher_.set_frame_busting(!is_privileged_);
+  url_fetcher_.set_frame_busting(!is_privileged());
   automation_client_->SetUrlFetcher(&url_fetcher_);
 
   // TODO(joshia): Initialize navigation here and send proxy config as
   // part of LaunchSettings
   /*
   if (!src_.empty())
-    automation_client_->InitiateNavigation(src_, is_privileged_);
+    automation_client_->InitiateNavigation(src_, is_privileged());
 
   std::string proxy_settings;
   bool has_prefs = pref_service_->Initialize(instance_,
                                              automation_client_.get());
   if (has_prefs && pref_service_->GetProxyValueJSONString(&proxy_settings)) {
     automation_client_->SetProxySettings(proxy_settings);
   }
   */
 
   // We can't call SubscribeToFocusEvents here since
@@ skipping 151 matching lines @@
 void ChromeFrameNPAPI::OnAcceleratorPressed(int tab_handle,
                                             const MSG& accel_message) {
   DVLOG(1) << __FUNCTION__
            << " msg:" << base::StringPrintf("0x%04X", accel_message.message)
            << " key:" << accel_message.wParam;
 
   // The host browser does call TranslateMessage on messages like WM_KEYDOWN
   // WM_KEYUP, etc, which will result in messages like WM_CHAR, WM_SYSCHAR, etc
   // being posted to the message queue. We don't post these messages here to
   // avoid these messages from getting handled twice.
-  if (!is_privileged_ &&
+  if (!is_privileged() &&
       accel_message.message != WM_CHAR &&
       accel_message.message != WM_DEADCHAR &&
       accel_message.message != WM_SYSCHAR &&
       accel_message.message != WM_SYSDEADCHAR) {
     // A very primitive way to handle keystrokes.
     // TODO(tommi): When we've implemented a way for chrome to
     //  know when keystrokes are handled (deterministically) on that side,
     //  then this function should get called and not otherwise.
     ::PostMessage(::GetParent(m_hWnd), accel_message.message,
                   accel_message.wParam, accel_message.lParam);
@@ skipping 176 matching lines @@
       return true;
     }
   } else if (name == plugin_property_identifiers_[PLUGIN_PROPERTY_ONMESSAGE]) {
     if (onmessage_handler_) {
       variant->type = NPVariantType_Object;
       variant->value.objectValue = onmessage_handler_.Copy();
       return true;
     }
   } else if (name ==
              plugin_property_identifiers_[PLUGIN_PROPERTY_ONPRIVATEMESSAGE]) {
-    if (!is_privileged_) {
+    if (!is_privileged()) {
       DLOG(WARNING) << "Attempt to read onprivatemessage property while not "
                        "privileged";
     } else {
       if (onprivatemessage_handler_) {
         variant->type = NPVariantType_Object;
         variant->value.objectValue =
             onprivatemessage_handler_.Copy();
         return true;
       }
     }
@@ skipping 12 matching lines @@
     AllocateStringVariant(WideToUTF8(version), variant);
     return true;
   } else if (name == plugin_property_identifiers_[PLUGIN_PROPERTY_READYSTATE]) {
     INT32_TO_NPVARIANT(ready_state_, *variant);
     return true;
   } else if (name ==
         plugin_property_identifiers_[PLUGIN_PROPERTY_USECHROMENETWORK]) {
     BOOLEAN_TO_NPVARIANT(automation_client_->use_chrome_network(), *variant);
     return true;
   } else if (name == plugin_property_identifiers_[PLUGIN_PROPERTY_SESSIONID]) {
-    if (!is_privileged_) {
+    if (!is_privileged()) {
       DLOG(WARNING) << "Attempt to read sessionid property while not "
                        "privileged";
     } else {
       INT32_TO_NPVARIANT(automation_client_->GetSessionId(), *variant);
       return true;
     }
   }
 
   return false;
 }
@@ skipping 21 matching lines @@
       onerror_handler_.Free();
       onerror_handler_ = variant->value.objectValue;
       return true;
     } else if (
         name == plugin_property_identifiers_[PLUGIN_PROPERTY_ONMESSAGE]) {
       onmessage_handler_.Free();
       onmessage_handler_ = variant->value.objectValue;
       return true;
     } else if (name ==
               plugin_property_identifiers_[PLUGIN_PROPERTY_ONPRIVATEMESSAGE]) {
-      if (!is_privileged_) {
+      if (!is_privileged()) {
         DLOG(WARNING) << "Attempt to set onprivatemessage while not privileged";
       } else {
         onprivatemessage_handler_.Free();
         onprivatemessage_handler_ = variant->value.objectValue;
         return true;
       }
     } else if (name == plugin_property_identifiers_[PLUGIN_PROPERTY_ONCLOSE]) {
       onclose_handler_.Free();
       onclose_handler_ = variant->value.objectValue;
       return true;
@@ skipping 91 matching lines @@
   ScopedNpVariant result;
   InvokeDefault(onerror_handler_, url, &result);
 }
 
 void ChromeFrameNPAPI::OnMessageFromChromeFrame(int tab_handle,
                                                 const std::string& message,
                                                 const std::string& origin,
                                                 const std::string& target) {
   bool private_message = false;
   if (target.compare("*") != 0) {
-    if (is_privileged_) {
+    if (is_privileged()) {
       private_message = true;
     } else {
       if (!HaveSameOrigin(target, document_url_)) {
         DLOG(WARNING) << "Dropping posted message since target doesn't match "
             "the current document's origin. target=" << target;
         return;
       }
     }
   }
 
   // Create a MessageEvent object that contains the message and origin
   // as well as supporting other MessageEvent (see the HTML5 spec) properties.
   // Then call the onmessage handler.
   ScopedNpObject<NPObject> event;
   bool ok = CreateMessageEvent(false, true, message, origin, event.Receive());
   if (ok) {
     // Don't call FireEvent here (or we'll have an event wrapped by an event).
     DispatchEvent(event);
 
     ScopedNpVariant result;
     NPVariant params[2];
     OBJECT_TO_NPVARIANT(event, params[0]);
     bool invoke = false;
     if (private_message) {
-      DCHECK(is_privileged_);
+      DCHECK(is_privileged());
       STRINGN_TO_NPVARIANT(target.c_str(), target.length(), params[1]);
       invoke = InvokeDefault(onprivatemessage_handler_,
                              arraysize(params),
                              params,
                              &result);
     } else {
       invoke = InvokeDefault(onmessage_handler_, params[0], &result);
     }
     DLOG_IF(WARNING, !invoke) << "InvokeDefault failed";
   } else {
@@ skipping 349 matching lines @@
 
   automation_client_->ForwardMessageFromExternalHost(message, origin, target);
 
   return true;
 }
 
 bool ChromeFrameNPAPI::postPrivateMessage(NPObject* npobject,
                                           const NPVariant* args,
                                           uint32_t arg_count,
                                           NPVariant* result) {
-  if (!is_privileged_) {
+  if (!is_privileged()) {
     DLOG(WARNING) << "postPrivateMessage invoked in non-privileged mode";
     return false;
   }
 
   if (arg_count != 3 || !NPVARIANT_IS_STRING(args[0]) ||
       !NPVARIANT_IS_STRING(args[1]) || !NPVARIANT_IS_STRING(args[2])) {
     NOTREACHED();
     return false;
   }
 
@@ skipping 12 matching lines @@
 bool ChromeFrameNPAPI::installExtension(NPObject* npobject,
                                         const NPVariant* args,
                                         uint32_t arg_count,
                                         NPVariant* result) {
   if (arg_count > 2 || !NPVARIANT_IS_STRING(args[0]) ||
       (arg_count == 2 && !NPVARIANT_IS_OBJECT(args[1]))) {
     NOTREACHED();
     return false;
   }
 
-  if (!is_privileged_) {
+  if (!is_privileged()) {
     DLOG(WARNING) << "installExtension invoked in non-privileged mode";
     return false;
   }
 
   if (!automation_client_.get()) {
     DLOG(WARNING) << "installExtension invoked with no automaton client";
     NOTREACHED();
     return false;
   }
 
@@ skipping 26 matching lines @@
 bool ChromeFrameNPAPI::loadExtension(NPObject* npobject,
                                      const NPVariant* args,
                                      uint32_t arg_count,
                                      NPVariant* result) {
   if (arg_count > 2 || !NPVARIANT_IS_STRING(args[0]) ||
       (arg_count == 2 && !NPVARIANT_IS_OBJECT(args[1]))) {
     NOTREACHED();
     return false;
   }
 
-  if (!is_privileged_) {
+  if (!is_privileged()) {
     DLOG(WARNING) << "loadExtension invoked in non-privileged mode";
     return false;
   }
 
   if (!automation_client_.get()) {
     DLOG(WARNING) << "loadExtension invoked with no automaton client";
     NOTREACHED();
     return false;
   }
 
@@ skipping 12 matching lines @@
 
 bool ChromeFrameNPAPI::enableExtensionAutomation(NPObject* npobject,
                                                  const NPVariant* args,
                                                  uint32_t arg_count,
                                                  NPVariant* result) {
   if (arg_count > 1 || (arg_count == 1 && !NPVARIANT_IS_STRING(args[0]))) {
     NOTREACHED();
     return false;
   }
 
-  if (!is_privileged_) {
+  if (!is_privileged()) {
     DLOG(WARNING) <<
         "enableExtensionAutomation invoked in non-privileged mode";
     return false;
   }
 
   if (!automation_client_.get()) {
     DLOG(WARNING) <<
         "enableExtensionAutomation invoked with no automaton client";
     NOTREACHED();
     return false;
@@ skipping 27 matching lines @@
 
 bool ChromeFrameNPAPI::getEnabledExtensions(NPObject* npobject,
                                             const NPVariant* args,
                                             uint32_t arg_count,
                                             NPVariant* result) {
   if (arg_count > 1 || !NPVARIANT_IS_OBJECT(args[0])) {
     NOTREACHED();
     return false;
   }
 
-  if (!is_privileged_) {
+  if (!is_privileged()) {
     DLOG(WARNING) << "getEnabledExtensions invoked in non-privileged mode";
     return false;
   }
 
   if (!automation_client_.get()) {
     DLOG(WARNING) << "getEnabledExtensions invoked with no automaton client";
     NOTREACHED();
     return false;
   }
 
@@ skipping 80 matching lines @@
   } else {
     DLOG(WARNING) << "Not checking for private mode in Opera";
   }
 
   return incognito_mode;
 }
 
 bool ChromeFrameNPAPI::PreProcessContextMenu(HMENU menu) {
   // TODO: Remove this overridden method once HandleContextMenuCommand
   // implements "About Chrome Frame" handling.
-  if (!is_privileged_) {
+  if (!is_privileged()) {
     // Call base class (adds 'About' item).
     return ChromeFramePlugin::PreProcessContextMenu(menu);
   }
   return true;
 }
 
 bool ChromeFrameNPAPI::HandleContextMenuCommand(UINT cmd,
     const IPC::MiniContextMenuParams& params) {
   if (cmd == IDC_ABOUT_CHROME_FRAME) {
     // TODO: implement "About Chrome Frame"
@@ skipping 11 matching lines @@
 }
 
 int32 ChromeFrameNPAPI::Write(NPStream* stream, int32 offset, int32 len,
                               void* buffer) {
   return url_fetcher_.Write(stream, offset, len, buffer);
 }
 
 NPError ChromeFrameNPAPI::DestroyStream(NPStream* stream, NPReason reason) {
   return url_fetcher_.DestroyStream(stream, reason);
 }