Change PermissionBubbleRequest::GetRequestingHostname to GetOrigin

chrome/browser/ui/website_settings/permission_bubble_manager.cc

 // Copyright 2014 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/ui/website_settings/permission_bubble_manager.h"
 
 #include "base/command_line.h"
 #include "base/metrics/user_metrics_action.h"
 #include "build/build_config.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_request.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/user_metrics.h"
 #include "url/origin.h"
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/ui/browser_finder.h"
 #endif
 
 namespace {
 
 class CancelledRequest : public PermissionBubbleRequest {
  public:
   explicit CancelledRequest(PermissionBubbleRequest* cancelled)
       : icon_(cancelled->GetIconId()),
         message_text_(cancelled->GetMessageText()),
         message_fragment_(cancelled->GetMessageTextFragment()),
         user_gesture_(cancelled->HasUserGesture()),
-        hostname_(cancelled->GetRequestingHostname()) {}
+        origin_(cancelled->GetOrigin()) {}
   ~CancelledRequest() override {}
 
   int GetIconId() const override { return icon_; }
   base::string16 GetMessageText() const override { return message_text_; }
   base::string16 GetMessageTextFragment() const override {
     return message_fragment_;
   }
   bool HasUserGesture() const override { return user_gesture_; }
-  GURL GetRequestingHostname() const override { return hostname_; }
+  GURL GetOrigin() const override { return origin_; }
 
   // These are all no-ops since the placeholder is non-forwarding.
   void PermissionGranted() override {}
   void PermissionDenied() override {}
   void Cancelled() override {}
 
   void RequestFinished() override { delete this; }
 
  private:
   int icon_;
   base::string16 message_text_;
   base::string16 message_fragment_;
   bool user_gesture_;
-  GURL hostname_;
+  GURL origin_;
 };
 
 }  // namespace
 
 // PermissionBubbleManager::Observer -------------------------------------------
 
 PermissionBubbleManager::Observer::~Observer() {
 }
 
 void PermissionBubbleManager::Observer::OnBubbleAdded() {
@@ skipping 34 matching lines @@
 
 void PermissionBubbleManager::AddRequest(PermissionBubbleRequest* request) {
   content::RecordAction(base::UserMetricsAction("PermissionBubbleRequest"));
   // TODO(gbillock): is there a race between an early request on a
   // newly-navigated page and the to-be-cleaned-up requests on the previous
   // page? We should maybe listen to DidStartNavigationToPendingEntry (and
   // any other renderer-side nav initiations?). Double-check this for
   // correct behavior on interstitials -- we probably want to basically queue
   // any request for which GetVisibleURL != GetLastCommittedURL.
   request_url_ = web_contents()->GetLastCommittedURL();
-  bool is_main_frame =
-      url::Origin(request_url_)
-          .IsSameOriginWith(url::Origin(request->GetRequestingHostname()));
+  bool is_main_frame = url::Origin(request_url_)
+                           .IsSameOriginWith(url::Origin(request->GetOrigin()));
 
   // Don't re-add an existing request or one with a duplicate text request.
   // TODO(johnme): Instead of dropping duplicate requests, we should queue them
   // and eventually run their PermissionGranted/PermissionDenied/Cancelled
   // callback (crbug.com/577313).
   bool same_object = false;
   if (ExistingRequest(request, requests_, &same_object) ||
       ExistingRequest(request, queued_requests_, &same_object) ||
       ExistingRequest(request, queued_frame_requests_, &same_object)) {
     if (!same_object)
@@ skipping 285 matching lines @@
   CHECK(same_object);
   *same_object = false;
   std::vector<PermissionBubbleRequest*>::const_iterator iter;
   for (iter = queue.begin(); iter != queue.end(); iter++) {
     if (*iter == request) {
       *same_object = true;
       return true;
     }
     if ((*iter)->GetMessageTextFragment() ==
             request->GetMessageTextFragment() &&
-        (*iter)->GetRequestingHostname() == request->GetRequestingHostname()) {
+        (*iter)->GetOrigin() == request->GetOrigin()) {
       return true;
     }
   }
   return false;
 }
 
 bool PermissionBubbleManager::HasUserGestureRequest(
     const std::vector<PermissionBubbleRequest*>& queue) {
   std::vector<PermissionBubbleRequest*>::const_iterator iter;
   for (iter = queue.begin(); iter != queue.end(); iter++) {
@@ skipping 23 matching lines @@
     case DENY_ALL:
       Deny();
       break;
     case DISMISS:
       Closing();
       break;
     case NONE:
       NOTREACHED();
   }
 }