The translate feature was only translating the main frame of the page....

chrome/renderer/translate/page_translator.cc

 // Copyright (c) 2010 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/renderer/translate/page_translator.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/task.h"
+#include "chrome/renderer/navigation_state.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDocument.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebNodeList.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebString.h"
 
 namespace {
 
 // The following elements are not supposed to be translated.
 const char* const kSkippedTags[] = { "APPLET", "AREA", "BASE", "FRAME",
@@ skipping 30 matching lines @@
   for (size_t i = 0; i < arraysize(kSkippedTags); ++i)
     ignored_tags_.insert(WebKit::WebString(ASCIIToUTF16(kSkippedTags[i])));
   for (size_t i = 0; i < arraysize(kInlineTags); ++i)
     inline_tags_.insert(WebKit::WebString(ASCIIToUTF16(kInlineTags[i])));
 }
 
 PageTranslator::~PageTranslator() {
   ResetPageStates();
 }
 
-void PageTranslator::Translate(int page_id,
-                               WebKit::WebFrame* web_frame,
-                               std::string source_lang,
-                               std::string target_lang) {
+void PageTranslator::TranslatePage(int page_id,
+                                   WebKit::WebFrame* main_frame,
+                                   std::string source_lang,
+                                   std::string target_lang) {
   if (page_id != page_id_) {
     // This is a new page, our states are invalid.
     ResetPageStates();
     page_id_ = page_id;
-    secure_page_ = static_cast<GURL>(web_frame->top()->url()).SchemeIsSecure();
+    secure_page_ = static_cast<GURL>(main_frame->top()->url()).SchemeIsSecure();
   }
   if (original_language_.empty()) {
     original_language_ = source_lang;
     current_language_ = source_lang;
   }
 
   if (original_language_ != current_language_) {
     // The page has already been translated.
     if (target_lang == current_language_) {
       NOTREACHED();
@@ skipping 14 matching lines @@
                                       secure_page_, this);
       pending_translations_[work_id] = *text_nodes_iter;
     }
     current_language_ = target_lang;
     return;
   }
 
   // We are about to start the translation process.
   current_language_ = target_lang;
 
+  // Translate all frames contained within the main-frame.
+  for (WebKit::WebFrame* frame = main_frame;
+       frame; frame = frame->traverseNext(false)) {
+    TranslateFrame(frame);
+  }
+}
+
+void PageTranslator::TranslateFrame(WebKit::WebFrame* web_frame) {
+  if (page_id_ == -1)
+    return;  // The page has not been translated, ignore.
+
+  DCHECK(!original_language_.empty() && !current_language_.empty());
+
+  WebKit::WebDataSource* ds = web_frame->dataSource();
+  NavigationState* navigation_state = NavigationState::FromDataSource(ds);
+  DCHECK(navigation_state);
+  if (navigation_state->was_translated())
+    return;  // This frame has already been translated, nothing to do.
+
+  // If the frame has no document or an empty document, it may not have been
+  // loaded yet.
+  if (web_frame->document().isNull() ||
+      web_frame->document().childNodes().length() == 0) {
+    return;
+  }
+
   std::stack<NodeList*> node_list_stack;
   std::vector<NodeList*> text_node_lists;
   TraverseNode(web_frame->document(), &node_list_stack, &text_node_lists);
 
   std::vector<NodeList*>::iterator iter;
   for (iter = text_node_lists.begin(); iter != text_node_lists.end(); ++iter) {
     if ((*iter)->empty()) {
       // Nothing to translate.
       continue;
     }
     TextChunks* text_chunks = new TextChunks;  // The text chunks to translate.
     NodeList::iterator text_nodes_iter;
     for (text_nodes_iter = (*iter)->begin();
          text_nodes_iter != (*iter)->end(); ++text_nodes_iter) {
       DCHECK(text_nodes_iter->isTextNode());
       string16 text = static_cast<string16>(text_nodes_iter->nodeValue());
       DCHECK(!ContainsOnlyWhitespace(text));
       text_chunks->push_back(text);
     }
 
     // Send the text for translation.
     int work_id =
-        text_translator_->Translate(*text_chunks, source_lang, target_lang,
+        text_translator_->Translate(*text_chunks,
+                                    original_language_, current_language_,
                                     secure_page_, this);
     pending_translations_[work_id] = *iter;
     // Also store the text nodes and their original text so we can translate to
     // another language if necessary.
     text_nodes_.push_back(*iter);
     text_chunks_.push_back(text_chunks);
   }
+
+  navigation_state->set_was_translated(true);
 }
 
-void PageTranslator::NavigatedToNewPage() {
+void PageTranslator::MainFrameNavigated() {
   // We can drop all our states, they were related to the previous page.
   ResetPageStates();
 }
 
+bool PageTranslator::IsPageTranslated() {
+  return original_language_ != current_language_;
+}
+
 bool PageTranslator::ShouldElementBeTraversed(WebKit::WebElement element) {
   return ignored_tags_.find(element.tagName()) == ignored_tags_.end();
 }
 
 bool PageTranslator::IsInlineElement(WebKit::WebElement element) {
   return inline_tags_.find(element.tagName()) != inline_tags_.end();
 }
 
 void PageTranslator::ClearNodeZone(int work_id) {
   std::map<int, NodeList*>::iterator iter = pending_translations_.find(work_id);
@@ skipping 94 matching lines @@
   STLDeleteElements(&text_nodes_);
   STLDeleteElements(&text_chunks_);
   original_language_.clear();
   current_language_.clear();
   ClearPendingTranslations();
 }
 
 void PageTranslator::ClearPendingTranslations() {
   pending_translations_.clear();
 }