This is followup of 449919 for addressing nit.

chrome/browser/renderer_context_menu/render_view_context_menu.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/renderer_context_menu/render_view_context_menu.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 994 matching lines @@
 
   if (id >= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_FIRST &&
       id <= IDC_CONTENT_CONTEXT_PROTOCOL_HANDLER_LAST) {
     return true;
   }
 
   IncognitoModePrefs::Availability incognito_avail =
       IncognitoModePrefs::GetAvailability(prefs);
   switch (id) {
     case IDC_BACK:
-      return embedded_web_contents_->GetController().CanGoBack();
+      return embedder_web_contents_->GetController().CanGoBack();
 
     case IDC_FORWARD:
-      return embedded_web_contents_->GetController().CanGoForward();
+      return embedder_web_contents_->GetController().CanGoForward();
 
     case IDC_RELOAD: {
       CoreTabHelper* core_tab_helper =
-          CoreTabHelper::FromWebContents(embedded_web_contents_);
+          CoreTabHelper::FromWebContents(embedder_web_contents_);
       if (!core_tab_helper)
         return false;
 
       CoreTabHelperDelegate* core_delegate = core_tab_helper->delegate();
       return !core_delegate ||
-             core_delegate->CanReloadContents(embedded_web_contents_);
+             core_delegate->CanReloadContents(embedder_web_contents_);
     }
 
     case IDC_VIEW_SOURCE:
     case IDC_CONTENT_CONTEXT_VIEWFRAMESOURCE:
-      return embedded_web_contents_->GetController().CanViewSource();
+      return embedder_web_contents_->GetController().CanViewSource();
 
     case IDC_CONTENT_CONTEXT_INSPECTELEMENT:
     case IDC_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE:
     case IDC_CONTENT_CONTEXT_RELOAD_PACKAGED_APP:
     case IDC_CONTENT_CONTEXT_RESTART_PACKAGED_APP:
       return IsDevCommandEnabled(id);
 
     case IDC_CONTENT_CONTEXT_VIEWPAGEINFO:
-      if (embedded_web_contents_->GetController().GetVisibleEntry() == NULL)
+      if (embedder_web_contents_->GetController().GetVisibleEntry() == NULL)
         return false;
       // Disabled if no browser is associated (e.g. desktop notifications).
-      if (chrome::FindBrowserWithWebContents(embedded_web_contents_) == NULL)
+      if (chrome::FindBrowserWithWebContents(embedder_web_contents_) == NULL)
         return false;
       return true;
 
     case IDC_CONTENT_CONTEXT_TRANSLATE: {
       ChromeTranslateClient* chrome_translate_client =
-          ChromeTranslateClient::FromWebContents(embedded_web_contents_);
+          ChromeTranslateClient::FromWebContents(embedder_web_contents_);
       if (!chrome_translate_client)
         return false;
       std::string original_lang =
           chrome_translate_client->GetLanguageState().original_language();
       std::string target_lang = g_browser_process->GetApplicationLocale();
       target_lang =
           translate::TranslateDownloadManager::GetLanguageCode(target_lang);
       // Note that we intentionally enable the menu even if the original and
       // target languages are identical.  This is to give a way to user to
       // translate a page that might contains text fragments in a different
       // language.
       return ((params_.edit_flags & WebContextMenuData::CanTranslate) != 0) &&
              !original_lang.empty() &&  // Did we receive the page language yet?
              !chrome_translate_client->GetLanguageState().IsPageTranslated() &&
-             !embedded_web_contents_->GetInterstitialPage() &&
+             !embedder_web_contents_->GetInterstitialPage() &&
              // There are some application locales which can't be used as a
              // target language for translation.
              translate::TranslateDownloadManager::IsSupportedLanguage(
                  target_lang) &&
              // Disable on the Instant Extended NTP.
-             !chrome::IsInstantNTP(embedded_web_contents_);
+             !chrome::IsInstantNTP(embedder_web_contents_);
     }
 
     case IDC_CONTENT_CONTEXT_OPENLINKNEWTAB:
     case IDC_CONTENT_CONTEXT_OPENLINKNEWWINDOW:
       return params_.link_url.is_valid();
 
     case IDC_CONTENT_CONTEXT_COPYLINKLOCATION:
       return params_.unfiltered_link_url.is_valid();
 
     case IDC_CONTENT_CONTEXT_SAVELINKAS: {
@@ skipping 74 matching lines @@
     }
 
     case IDC_CONTENT_CONTEXT_OPENAVNEWTAB:
       // Currently, a media element can be opened in a new tab iff it can
       // be saved. So rather than duplicating the MediaCanSave flag, we rely
       // on that here.
       return !!(params_.media_flags & WebContextMenuData::MediaCanSave);
 
     case IDC_SAVE_PAGE: {
       CoreTabHelper* core_tab_helper =
-          CoreTabHelper::FromWebContents(embedded_web_contents_);
+          CoreTabHelper::FromWebContents(embedder_web_contents_);
       if (!core_tab_helper)
         return false;
 
       CoreTabHelperDelegate* core_delegate = core_tab_helper->delegate();
       if (core_delegate &&
-          !core_delegate->CanSaveContents(embedded_web_contents_))
+          !core_delegate->CanSaveContents(embedder_web_contents_))
         return false;
 
       PrefService* local_state = g_browser_process->local_state();
       DCHECK(local_state);
       // Test if file-selection dialogs are forbidden by policy.
       if (!local_state->GetBoolean(prefs::kAllowFileSelectionDialogs))
         return false;
 
       // We save the last committed entry (which the user is looking at), as
       // opposed to any pending URL that hasn't committed yet.
       NavigationEntry* entry =
-          embedded_web_contents_->GetController().GetLastCommittedEntry();
+          embedder_web_contents_->GetController().GetLastCommittedEntry();
       return content::IsSavableURL(entry ? entry->GetURL() : GURL());
     }
 
     case IDC_CONTENT_CONTEXT_RELOADFRAME:
       return params_.frame_url.is_valid();
 
     case IDC_CONTENT_CONTEXT_UNDO:
       return !!(params_.edit_flags & WebContextMenuData::CanUndo);
 
     case IDC_CONTENT_CONTEXT_REDO:
@@ skipping 265 matching lines @@
 
     case IDC_CONTENT_CONTEXT_ROTATECCW:
       content::RecordAction(
       UserMetricsAction("PluginContextMenu_RotateCounterclockwise"));
       PluginActionAt(
           gfx::Point(params_.x, params_.y),
           WebPluginAction(WebPluginAction::Rotate90Counterclockwise, true));
       break;
 
     case IDC_BACK:
-      embedded_web_contents_->GetController().GoBack();
+      embedder_web_contents_->GetController().GoBack();
       break;
 
     case IDC_FORWARD:
-      embedded_web_contents_->GetController().GoForward();
+      embedder_web_contents_->GetController().GoForward();
       break;
 
     case IDC_SAVE_PAGE:
-      embedded_web_contents_->OnSavePage();
+      embedder_web_contents_->OnSavePage();
       break;
 
     case IDC_RELOAD:
-      embedded_web_contents_->GetController().Reload(true);
+      embedder_web_contents_->GetController().Reload(true);
       break;
 
     case IDC_CONTENT_CONTEXT_RELOAD_PACKAGED_APP: {
       const Extension* platform_app = GetExtension();
       DCHECK(platform_app);
       DCHECK(platform_app->is_platform_app());
 
       extensions::ExtensionSystem::Get(browser_context_)
           ->extension_service()
           ->ReloadExtension(platform_app->id());
@@ skipping 22 matching lines @@
 
       printing::StartPrint(
           source_web_contents_,
           GetPrefs(browser_context_)->GetBoolean(prefs::kPrintPreviewDisabled),
           !params_.selection_text.empty());
 #endif  // ENABLE_PRINTING
       break;
     }
 
     case IDC_VIEW_SOURCE:
-      embedded_web_contents_->ViewSource();
+      embedder_web_contents_->ViewSource();
       break;
 
     case IDC_CONTENT_CONTEXT_INSPECTELEMENT:
       Inspect(params_.x, params_.y);
       break;
 
     case IDC_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE: {
       const Extension* platform_app = GetExtension();
       DCHECK(platform_app);
       DCHECK(platform_app->is_platform_app());
 
       extensions::devtools_util::InspectBackgroundPage(platform_app,
                                                        GetProfile());
       break;
     }
 
     case IDC_CONTENT_CONTEXT_VIEWPAGEINFO: {
       NavigationController* controller =
-          &embedded_web_contents_->GetController();
+          &embedder_web_contents_->GetController();
       // Important to use GetVisibleEntry to match what's showing in the
       // omnibox.  This may return null.
       NavigationEntry* nav_entry = controller->GetVisibleEntry();
       if (!nav_entry)
         return;
       Browser* browser =
-          chrome::FindBrowserWithWebContents(embedded_web_contents_);
-      chrome::ShowWebsiteSettings(browser, embedded_web_contents_,
+          chrome::FindBrowserWithWebContents(embedder_web_contents_);
+      chrome::ShowWebsiteSettings(browser, embedder_web_contents_,
                                   nav_entry->GetURL(), nav_entry->GetSSL());
       break;
     }
 
     case IDC_CONTENT_CONTEXT_TRANSLATE: {
       // A translation might have been triggered by the time the menu got
       // selected, do nothing in that case.
       ChromeTranslateClient* chrome_translate_client =
-          ChromeTranslateClient::FromWebContents(embedded_web_contents_);
+          ChromeTranslateClient::FromWebContents(embedder_web_contents_);
       if (!chrome_translate_client ||
           chrome_translate_client->GetLanguageState().IsPageTranslated() ||
           chrome_translate_client->GetLanguageState().translation_pending()) {
         return;
       }
       std::string original_lang =
           chrome_translate_client->GetLanguageState().original_language();
       std::string target_lang = g_browser_process->GetApplicationLocale();
       target_lang =
           translate::TranslateDownloadManager::GetLanguageCode(target_lang);
@@ skipping 212 matching lines @@
   source_web_contents_->GetRenderViewHost()->
       ExecuteMediaPlayerActionAtLocation(location, action);
 }
 
 void RenderViewContextMenu::PluginActionAt(
     const gfx::Point& location,
     const WebPluginAction& action) {
   source_web_contents_->GetRenderViewHost()->
       ExecutePluginActionAtLocation(location, action);
 }