Fix webrequest api for webview in webui

extensions/browser/api/web_request/web_request_api.cc

 // Copyright (c) 2012 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 "extensions/browser/api/web_request/web_request_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 2195 matching lines @@
 
   int webview_instance_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(5, &webview_instance_id));
 
   base::WeakPtr<extensions::ExtensionMessageFilter> ipc_sender =
       ipc_sender_weak();
   int embedder_process_id =
       ipc_sender.get() ? ipc_sender->render_process_id() : -1;
 
   const Extension* extension =
-      extension_info_map()->extensions().GetByID(extension_id());
-  std::string extension_name = extension ? extension->name() : extension_id();
+      extension_info_map()->extensions().GetByID(extension_id_safe());
+  std::string extension_name =
+      extension ? extension->name() : extension_id_safe();
 
   bool is_web_view_guest = webview_instance_id != 0;
   // We check automatically whether the extension has the 'webRequest'
   // permission. For blocking calls we require the additional permission
   // 'webRequestBlocking'.
   if ((!is_web_view_guest &&
        extra_info_spec &
            (ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING |
             ExtensionWebRequestEventRouter::ExtraInfoSpec::ASYNC_BLOCKING)) &&
       !extension->permissions_data()->HasAPIPermission(
           extensions::APIPermission::kWebRequestBlocking)) {
     error_ = keys::kBlockingPermissionRequired;
     return false;
   }
 
   // We allow to subscribe to patterns that are broader than the host
   // permissions. E.g., we could subscribe to http://www.example.com/*
   // while having host permissions for http://www.example.com/foo/* and
   // http://www.example.com/bar/*.
   // For this reason we do only a coarse check here to warn the extension
   // developer if he does something obviously wrong.
   if (!is_web_view_guest &&
       extension->permissions_data()->GetEffectiveHostPermissions().is_empty()) {
     error_ = keys::kHostPermissionsRequired;
     return false;
   }
 
   bool success =
       ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
-          profile_id(), extension_id(), extension_name,
+          profile_id(), extension_id_safe(), extension_name,
           event_name, sub_event_name, filter, extra_info_spec,
           embedder_process_id, webview_instance_id, ipc_sender_weak());
   EXTENSION_FUNCTION_VALIDATE(success);
 
   helpers::ClearCacheOnNavigation();
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&helpers::NotifyWebRequestAPIUsed,
                                      profile_id(),
                                      make_scoped_refptr(extension)));
 
   return true;
 }
 
 void WebRequestInternalEventHandledFunction::RespondWithError(
     const std::string& event_name,
     const std::string& sub_event_name,
     uint64 request_id,
     scoped_ptr<ExtensionWebRequestEventRouter::EventResponse> response,
     const std::string& error) {
   error_ = error;
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile_id(),
-      extension_id(),
+      extension_id_safe(),
       event_name,
       sub_event_name,
       request_id,
       response.release());
 }
 
 bool WebRequestInternalEventHandledFunction::RunSync() {
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
 
   std::string sub_event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &sub_event_name));
 
   std::string request_id_str;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &request_id_str));
   uint64 request_id;
   EXTENSION_FUNCTION_VALIDATE(base::StringToUint64(request_id_str,
                                                    &request_id));
 
   scoped_ptr<ExtensionWebRequestEventRouter::EventResponse> response;
   if (HasOptionalArgument(3)) {
     base::DictionaryValue* value = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(3, &value));
 
     if (!value->empty()) {
       base::Time install_time =
-          extension_info_map()->GetInstallTime(extension_id());
+          extension_info_map()->GetInstallTime(extension_id_safe());
       response.reset(new ExtensionWebRequestEventRouter::EventResponse(
-          extension_id(), install_time));
+          extension_id_safe(), install_time));
     }
 
     if (value->HasKey("cancel")) {
       // Don't allow cancel mixed with other keys.
       if (value->size() != 1) {
         RespondWithError(event_name,
                          sub_event_name,
                          request_id,
                          response.Pass(),
                          keys::kInvalidBlockingResponse);
@@ skipping 102 matching lines @@
       EXTENSION_FUNCTION_VALIDATE(
           credentials_value->GetString(keys::kUsernameKey, &username));
       EXTENSION_FUNCTION_VALIDATE(
           credentials_value->GetString(keys::kPasswordKey, &password));
       response->auth_credentials.reset(
           new net::AuthCredentials(username, password));
     }
   }
 
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
-      profile_id(), extension_id(), event_name, sub_event_name, request_id,
+      profile_id(), extension_id_safe(), event_name, sub_event_name, request_id,
       response.release());
 
   return true;
 }
 
 void WebRequestHandlerBehaviorChangedFunction::GetQuotaLimitHeuristics(
     extensions::QuotaLimitHeuristics* heuristics) const {
   extensions::QuotaLimitHeuristic::Config config = {
       // See web_request.json for current value.
       web_request::MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES,
       base::TimeDelta::FromMinutes(10)};
   extensions::QuotaLimitHeuristic::BucketMapper* bucket_mapper =
       new extensions::QuotaLimitHeuristic::SingletonBucketMapper();
   ClearCacheQuotaHeuristic* heuristic =
       new ClearCacheQuotaHeuristic(config, bucket_mapper);
   heuristics->push_back(heuristic);
 }
 
 void WebRequestHandlerBehaviorChangedFunction::OnQuotaExceeded(
     const std::string& violation_error) {
   // Post warning message.
   WarningSet warnings;
   warnings.insert(
-      Warning::CreateRepeatedCacheFlushesWarning(extension_id()));
+      Warning::CreateRepeatedCacheFlushesWarning(extension_id_safe()));
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WarningService::NotifyWarningsOnUI, profile_id(), warnings));
 
   // Continue gracefully.
   RunSync();
 }
 
 bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }