Fix HDCP in mirror mode.

ash/display/display_manager.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 "ash/display/display_manager.h"
 
 #include <cmath>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 281 matching lines @@
   NOTREACHED() << "DisplayLayout is requested for single display";
   // On release build, just fallback to default instead of blowing up.
   DisplayLayout layout =
       layout_store_->default_display_layout();
   layout.primary_id = displays_[0].id();
   return layout;
 }
 
 DisplayIdPair DisplayManager::GetCurrentDisplayIdPair() const {
   if (IsMirrored()) {
-    if (software_mirroring_enabled()) {
+    if (SoftwareMirroringEnabled()) {
       CHECK_EQ(2u, num_connected_displays());
       // This comment is to make it easy to distinguish the crash
       // between two checks.
       CHECK_EQ(1u, displays_.size());
     }
     return std::make_pair(displays_[0].id(), mirrored_display_id_);
   } else {
     CHECK_GE(2u, displays_.size());
     int64 id_at_zero = displays_[0].id();
     if (id_at_zero == gfx::Display::InternalDisplayId() ||
@@ skipping 629 matching lines @@
   second_display_mode_ = mode;
   mirrored_display_id_ = gfx::Display::kInvalidDisplayID;
   non_desktop_display_ = gfx::Display();
 }
 
 bool DisplayManager::UpdateDisplayBounds(int64 display_id,
                                          const gfx::Rect& new_bounds) {
   if (change_display_upon_host_resize_) {
     display_info_[display_id].SetBounds(new_bounds);
     // Don't notify observers if the mirrored window has changed.
-    if (software_mirroring_enabled() && mirrored_display_id_ == display_id)
+    if (SoftwareMirroringEnabled() && mirrored_display_id_ == display_id)
       return false;
     gfx::Display* display = FindDisplayForId(display_id);
     display->SetSize(display_info_[display_id].size_in_pixel());
     screen_ash_->NotifyBoundsChanged(*display);
     return true;
   }
   return false;
 }
 
 void DisplayManager::CreateMirrorWindowIfAny() {
@@ skipping 19 matching lines @@
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == id)
       return &(*iter);
   }
   DLOG(WARNING) << "Could not find display:" << id;
   return NULL;
 }
 
 void DisplayManager::AddMirrorDisplayInfoIfAny(
     std::vector<DisplayInfo>* display_info_list) {
-  if (software_mirroring_enabled() && IsMirrored())
+  if (SoftwareMirroringEnabled() && IsMirrored())
     display_info_list->push_back(GetDisplayInfo(mirrored_display_id_));
 }
 
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
   std::map<int64, DisplayInfo>::iterator info =
       display_info_.find(new_info.id());
   if (info != display_info_.end()) {
     info->second.Copy(new_info);
   } else {
     display_info_[new_info.id()] = new_info;
@@ skipping 112 matching lines @@
       new_secondary_origin.Offset(-secondary_bounds.width(), offset);
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace ash