[WebsiteSettings] Enable permission bubbles by default.

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 "chrome/browser/profiles/profile.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"
 
 namespace {
 
 class CancelledRequest : public PermissionBubbleRequest {
  public:
@@ skipping 45 matching lines @@
 // static
 bool PermissionBubbleManager::Enabled() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePermissionsBubbles))
     return true;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePermissionsBubbles))
     return false;
 
-  return false;
+  return true;
 }
 
 PermissionBubbleManager::PermissionBubbleManager(
     content::WebContents* web_contents)
   : content::WebContentsObserver(web_contents),
     bubble_showing_(false),
     view_(NULL),
     request_url_has_loaded_(false),
     customization_mode_(false),
     weak_factory_(this) {}
 
 PermissionBubbleManager::~PermissionBubbleManager() {
   if (view_ != NULL)
     view_->SetDelegate(NULL);
 
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     (*requests_iter)->RequestFinished();
   }
   for (requests_iter = queued_requests_.begin();
        requests_iter != queued_requests_.end();
        requests_iter++) {
     (*requests_iter)->RequestFinished();
   }
 }
 
 void PermissionBubbleManager::AddRequest(PermissionBubbleRequest* request) {
+LOG(INFO) << "!!! AddRequest " << request->GetMessageText();
   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 =
       request->GetRequestingHostname().GetOrigin() == request_url_.GetOrigin();
@@ skipping 150 matching lines @@
   accept_states_[request_index] = new_value;
 }
 
 void PermissionBubbleManager::SetCustomizationMode() {
   customization_mode_ = true;
   if (view_)
     view_->Show(requests_, accept_states_, customization_mode_);
 }
 
 void PermissionBubbleManager::Accept() {
+LOG(INFO) << "Accept bubble in MGR";
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   std::vector<bool>::iterator accepts_iter = accept_states_.begin();
   for (requests_iter = requests_.begin(), accepts_iter = accept_states_.begin();
        requests_iter != requests_.end();
        requests_iter++, accepts_iter++) {
     if (*accepts_iter)
       (*requests_iter)->PermissionGranted();
     else
       (*requests_iter)->PermissionDenied();
   }
@@ skipping 22 matching lines @@
 
 void PermissionBubbleManager::ScheduleShowBubble() {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&PermissionBubbleManager::TriggerShowBubble,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PermissionBubbleManager::TriggerShowBubble() {
-  if (!view_)
+LOG(INFO) << "TriggerShowBubble";
+  if (!view_) {
+LOG(INFO) << "no view";
     return;
+  }
   if (bubble_showing_)
     return;
-  if (!request_url_has_loaded_)
+  if (!request_url_has_loaded_) {
+LOG(INFO) << "not loaded";
     return;
+  }
   if (requests_.empty() && queued_requests_.empty() &&
       queued_frame_requests_.empty()) {
     return;
   }
 
   if (requests_.empty()) {
     // Queues containing a user-gesture-generated request have priority.
     if (HasUserGestureRequest(queued_requests_))
       requests_.swap(queued_requests_);
     else if (HasUserGestureRequest(queued_frame_requests_))
       requests_.swap(queued_frame_requests_);
     else if (queued_requests_.size())
       requests_.swap(queued_requests_);
     else
       requests_.swap(queued_frame_requests_);
 
     // Sets the default value for each request to be 'accept'.
     // TODO(leng):  Currently all requests default to true.  If that changes:
     // a) Add additional accept_state queues to store default values.
     // b) Change the request API to provide the default value.
     accept_states_.resize(requests_.size(), true);
   }
 
+LOG(INFO) << "showing bubble view";
   // Note: this should appear above Show() for testing, since in that
   // case we may do in-line calling of finalization.
   bubble_showing_ = true;
   view_->Show(requests_, accept_states_, customization_mode_);
 }
 
 void PermissionBubbleManager::FinalizeBubble() {
   if (view_)
     view_->Hide();
   bubble_showing_ = false;
@@ skipping 52 matching lines @@
 bool PermissionBubbleManager::HasUserGestureRequest(
     const std::vector<PermissionBubbleRequest*>& queue) {
   std::vector<PermissionBubbleRequest*>::const_iterator iter;
   for (iter = queue.begin(); iter != queue.end(); iter++) {
     if ((*iter)->HasUserGesture())
       return true;
   }
   return false;
 }