.github/workflows/release.yml

@@ -47,7 +47,7 @@ jobs:
 
     - name: Rename binary with platform suffix
       run: |
-        mv build/tut build/tut-${{ matrix.name }}
+        mv build/tut2 build/tut-${{ matrix.name }}
 
     - name: Upload artifact
       uses: actions/upload-artifact@v4

CMakeLists.txt

@@ -139,33 +139,3 @@ add_executable(test_history
     src/history.cpp
     tests/test_history.cpp
 )
-
-# 异步图片下载测试
-add_executable(test_async_images
-    src/http_client.cpp
-    tests/test_async_images.cpp
-)
-
-target_link_libraries(test_async_images
-    CURL::libcurl
-)
-
-# 简单图片测试
-add_executable(test_simple_image
-    src/http_client.cpp
-    tests/test_simple_image.cpp
-)
-
-target_link_libraries(test_simple_image
-    CURL::libcurl
-)
-
-# 最小图片测试
-add_executable(test_image_minimal
-    src/http_client.cpp
-    tests/test_image_minimal.cpp
-)
-
-target_link_libraries(test_image_minimal
-    CURL::libcurl
-)

NEXT_STEPS.md

@@ -1,9 +1,9 @@
 # TUT 2.0 - 下次继续从这里开始
 
 ## 当前位置
-- **阶段**: Phase 10 - 异步图片加载 (已完成!)
-- **进度**: 多并发图片下载、渐进式渲染、非阻塞UI
-- **最后提交**: `feat: Add async image loading with progressive rendering`
+- **阶段**: Phase 9 - 性能优化和测试工具 (已完成!)
+- **进度**: 图片缓存、测试工具、文档完善
+- **最后提交**: `feat: Add comprehensive testing tools and improve help`
 
 ## 立即可做的事
 
@@ -34,16 +34,6 @@
 
 ## 已完成的功能清单
 
-### Phase 10 - 异步图片加载
-- [x] 异步二进制下载接口 (HttpClient)
-- [x] 图片下载队列管理
-- [x] 多并发下载 (最多3张图片同时下载)
-- [x] 渐进式渲染 (图片下载完立即显示)
-- [x] 非阻塞UI (下载时可正常浏览)
-- [x] 实时进度显示
-- [x] Esc取消图片加载
-- [x] 保留图片缓存系统兼容
-
 ### Phase 9 - 性能优化和测试工具
 - [x] 图片 LRU 缓存 (100张，10分钟过期)
 - [x] 缓存命中统计显示
@@ -211,10 +201,10 @@ cmake --build build
 
 ## 下一步功能优先级
 
-1. **Cookie 持久化** - 保存和自动发送 Cookie (已有内存Cookie支持)
-2. **表单提交改进** - 文件上传、multipart/form-data
-3. **更多HTML5支持** - <table>表格渲染、<pre>代码块
-4. **性能优化** - DNS缓存、连接复用、HTTP/2
+1. **异步图片加载** - 图片也使用异步加载
+2. **Cookie 支持** - 保存和发送 Cookie
+3. **表单提交** - 实现 POST 表单提交
+4. **更多HTML5支持** - 更完善的HTML渲染
 
 ## 恢复对话时说
 
@@ -250,17 +240,8 @@ cmake --build build
 ✓ **表单** - 文本输入、复选框、下拉选择
 ✓ **书签** - 持久化书签管理
 ✓ **历史** - 浏览历史记录
-✓ **图片** - ASCII艺术渲染、智能缓存、异步加载
-✓ **性能** - LRU缓存、差分渲染、异步加载、多并发下载
-
-## 技术亮点
-
-- **完全异步**: 页面和图片都使用异步加载，UI永不阻塞
-- **渐进式渲染**: 图片下载完立即显示，无需等待全部完成
-- **多并发下载**: 最多3张图片同时下载，显著提升加载速度
-- **智能缓存**: 页面5分钟缓存、图片10分钟缓存，LRU策略
-- **差分渲染**: 只更新变化的屏幕区域，减少闪烁
-- **真彩色支持**: 24位True Color图片渲染
+✓ **图片** - ASCII艺术渲染、智能缓存
+✓ **性能** - LRU缓存、差分渲染、异步加载
 
 ---
 更新时间: 2025-12-28

REAL_WORLD_TEST_REPORT.md

@@ -1,390 +0,0 @@
-# TUT Browser - Real World Testing Report
-**Date**: 2025-12-28
-**Version**: 2.0.0 (with Phase 10 async image loading)
-**Tester**: Automated + Manual Evaluation
-
-## Testing Methodology
-
-We tested TUT with various website categories to evaluate:
-- ✅ **Loading Speed**: How quickly content becomes readable
-- ✅ **Image Loading**: Async behavior and progressive rendering
-- ✅ **Readability**: Content clarity and layout quality
-- ✅ **Responsiveness**: UI interaction during loading
-- ✅ **Overall UX**: Real human experience
-
----
-
-## Test Results by Category
-
-### 1️⃣ Simple Static Sites
-
-#### Example.com (https://example.com)
-- **Loading**: ⚡ Instant (< 1 second)
-- **Images**: No images
-- **Readability**: ⭐⭐⭐⭐⭐ Excellent
-- **Content**: Clean, centered text with proper spacing
-- **Experience**: Perfect for simple pages
-
-**Notes**:
-- Title renders correctly
-- Links are highlighted and navigable
-- Smooth scrolling experience
-- No issues detected
-
----
-
-#### Motherfucking Website (https://motherfuckingwebsite.com)
-- **Loading**: ⚡ Instant
-- **Images**: None
-- **Readability**: ⭐⭐⭐⭐⭐ Excellent
-- **Content**: Long-form text with good line width
-- **Experience**: Great for text-heavy content
-
-**Notes**:
-- Excellent for reading long articles
-- Good contrast with warm color scheme
-- vim-style navigation feels natural
-- Perfect for distraction-free reading
-
----
-
-### 2️⃣ News & Discussion Sites
-
-#### Hacker News (https://news.ycombinator.com)
-- **Loading**: ⚡ Fast (~1-2 seconds)
-- **Images**: Minimal (logo only)
-- **Readability**: ⭐⭐⭐⭐⭐ Excellent
-- **Content**: Compact list layout works well
-- **Experience**: Highly usable
-
-**Notes**:
-- News titles are clear and clickable
-- Point counts and metadata visible
-- Tab navigation between links works perfectly
-- Great for browsing headlines
-- No JavaScript needed - works flawlessly
-- **VERDICT**: One of the best use cases for TUT!
-
----
-
-#### Lobsters (https://lobste.rs)
-- **Loading**: ⚡ Fast (~1-2 seconds)
-- **Images**: User avatars (async load)
-- **Readability**: ⭐⭐⭐⭐ Very Good
-- **Content**: Clean thread list
-- **Experience**: Good
-
-**Notes**:
-- Links are well-organized
-- Tags and categories visible
-- Async image loading doesn't block content
-- Minor: Some layout elements from CSS missing
-- **VERDICT**: Very usable for tech news
-
----
-
-### 3️⃣ Documentation Sites
-
-#### curl Manual Page (https://curl.se/docs/manpage.html)
-- **Loading**: Medium (~2-3 seconds)
-- **Images**: Few technical diagrams
-- **Readability**: ⭐⭐⭐⭐ Very Good
-- **Content**: Code blocks and technical text
-- **Experience**: Usable
-
-**Notes**:
-- Long technical content renders well
-- Code blocks need better formatting (no `<pre>` support yet)
-- Search function (`/`) very useful for finding options
-- Good for quick reference
-- **IMPROVEMENT NEEDED**: Better `<pre>` and `<code>` rendering
-
----
-
-#### Rust Book (https://doc.rust-lang.org/book/)
-- **Loading**: Medium (~2-3 seconds)
-- **Images**: Code diagrams (async)
-- **Readability**: ⭐⭐⭐⭐ Very Good
-- **Content**: Educational text with examples
-- **Experience**: Good for learning
-
-**Notes**:
-- Chapter navigation works
-- Code examples readable but could be better formatted
-- Async image loading for diagrams is smooth
-- Marks (`ma`, `'a`) useful for bookmarking chapters
-- **VERDICT**: Decent for technical reading
-
----
-
-### 4️⃣ Wikipedia
-
-#### Wikipedia - Unix (https://en.wikipedia.org/wiki/Unix)
-- **Loading**: Slow (~4-5 seconds for content + images)
-- **Images**: **Many** (diagrams, screenshots, photos)
-- **Readability**: ⭐⭐⭐ Good (with some issues)
-- **Content**: Dense encyclopedic text
-- **Experience**: Acceptable but needs improvements
-
-**Notes**:
-- **Main content loads fast** - can start reading immediately
-- **Images load progressively** - see them appear one by one
-- Infoboxes and tables have layout issues (no table support)
-- Reference links [1][2][3] visible
-- **ASYNC IMAGE LOADING WORKS WELL**:
-  - Page is usable while images download
-  - Progress indicator shows "Loading images 3/8"
-  - Can scroll and navigate during image loading
-- **IMPROVEMENT NEEDED**: Table rendering for infoboxes
-
-**Real UX Experience**:
-```
-0s:  Page title appears, can start reading
-1s:  Main text content loaded, fully readable
-2s:  First 3 images appear (3 concurrent downloads)
-3s:  Next batch of images loads
-4s:  All images complete
-```
-**UI stayed responsive throughout!** ✅
-
----
-
-#### Wikipedia - World Wide Web (https://en.wikipedia.org/wiki/World_Wide_Web)
-- **Loading**: Similar to Unix page (~4-5s total)
-- **Images**: Multiple historical diagrams and screenshots
-- **Readability**: ⭐⭐⭐ Good
-- **Content**: Technical history, well-structured
-- **Experience**: Good with progressive loading
-
-**Notes**:
-- Can read introduction while images load in background
-- Timeline sections readable
-- ASCII art rendering of diagrams is interesting but low-fi
-- **Progressive rendering really shines here**
-- No UI freezing even with 10+ images
-
----
-
-### 5️⃣ Tech Blogs
-
-#### LWN.net (https://lwn.net)
-- **Loading**: Fast (~2 seconds)
-- **Images**: Few embedded images
-- **Readability**: ⭐⭐⭐⭐ Very Good
-- **Content**: Article headlines and summaries
-- **Experience**: Good for browsing
-
-**Notes**:
-- Article summaries clear and navigable
-- Links to full articles work well
-- Subscription wall notice visible
-- Good for tech news consumption
-
----
-
-## Summary Statistics
-
-### Performance Metrics
-
-| Site Type | Avg Load Time | Image Count | Readability | Usability |
-|-----------|--------------|-------------|-------------|-----------|
-| Simple Static | 0.5s | 0 | ⭐⭐⭐⭐⭐ | Excellent |
-| News Sites | 1-2s | 0-5 | ⭐⭐⭐⭐⭐ | Excellent |
-| Documentation | 2-3s | 3-10 | ⭐⭐⭐⭐ | Very Good |
-| Wikipedia | 4-5s | 8-15 | ⭐⭐⭐ | Good |
-| Tech Blogs | 2s | 2-8 | ⭐⭐⭐⭐ | Very Good |
-
----
-
-## Async Image Loading - Real World Performance
-
-### ✅ What Works Great
-
-1. **Non-Blocking UI**
-   - Can scroll, navigate, search while images download
-   - Esc key cancels loading instantly
-   - No frozen UI at any point
-
-2. **Progressive Rendering**
-   - Content appears immediately
-   - Images pop in as they finish
-   - Always know what's loading (progress indicator)
-
-3. **Parallel Downloads**
-   - 3 concurrent downloads significantly faster than sequential
-   - Wikipedia with 10 images: ~4s vs estimated ~12s sequential
-   - **3x speedup confirmed in real usage!**
-
-4. **Cache Performance**
-   - Revisiting pages is instant
-   - Cached images don't re-download
-   - Status shows "cached: 5" when applicable
-
-### 📊 Before/After Comparison
-
-**OLD (Synchronous Loading)**:
-```
-Load Wikipedia Unix page:
-0s:  "Loading..." - UI FROZEN
-5s:  "Downloading image 1/10..." - UI FROZEN
-10s: "Downloading image 2/10..." - UI FROZEN
-15s: "Downloading image 3/10..." - UI FROZEN
-...
-50s: Page finally usable
-```
-
-**NEW (Async Loading)**:
-```
-Load Wikipedia Unix page:
-0s:  Title and text appear - START READING
-1s:  Can scroll, navigate, search
-2s:  First 3 images appear (parallel download)
-3s:  Next 3 images appear
-4s:  All images complete
-     UI responsive the ENTIRE time!
-```
-
-**Human Experience**: **MASSIVELY BETTER** ✅
-
----
-
-## Readability Assessment
-
-### What Makes Content Readable in TUT?
-
-✅ **Excellent for**:
-- News aggregators (HN, Lobsters, Reddit text)
-- Blog posts and articles
-- Documentation (with minor limitations)
-- Long-form reading
-- Technical reference material
-
-⚠️ **Limitations**:
-- No `<table>` support (infoboxes, data tables render poorly)
-- No `<pre>` formatting (code blocks not monospaced)
-- No CSS layout (multi-column layouts flatten)
-- JavaScript-heavy sites don't work
-
-### Content Clarity
-
-- **Font**: Readable terminal font with good spacing
-- **Colors**: Warm color scheme easy on eyes
-- **Contrast**: Good foreground/background contrast
-- **Line Width**: Appropriate for reading (not too wide)
-- **Scrolling**: Smooth with vim keys (j/k)
-
-### Navigation Experience
-
-- **Tab**: Jump between links - works great
-- **Enter**: Follow links - instant
-- **h/l**: Back/forward - smooth
-- **/**: Search - very useful for finding content
-- **Esc**: Cancel loading - responsive
-
----
-
-## Real Human Feelings 🧑‍💻
-
-### What Users Will Love ❤️
-
-1. **Speed**: "It's so fast! Content appears instantly."
-2. **Simplicity**: "No ads, no tracking, no distractions."
-3. **Keyboard Control**: "vim keys everywhere - feels natural."
-4. **Readability**: "Text-focused, perfect for reading articles."
-5. **Lightweight**: "Doesn't slow down my machine."
-
-### What Users Will Notice 🤔
-
-1. **Image Quality**: "ASCII art images are fun but low-resolution."
-2. **Missing Tables**: "Wikipedia infoboxes are messy."
-3. **Layout**: "Some sites look different without CSS."
-4. **No JavaScript**: "Modern web apps don't work."
-
-### Best Use Cases ⭐
-
-1. **News Browsing**: Hacker News, Lobsters, Reddit (text)
-2. **Documentation**: Reading technical docs and manuals
-3. **Wikipedia**: Quick research (despite table issues)
-4. **Blogs**: Reading articles and essays
-5. **Learning**: Following tutorials and guides
-
-### Not Ideal For ❌
-
-1. Shopping sites (complex layouts)
-2. Social media (JavaScript-heavy)
-3. Modern web apps (React/Vue sites)
-4. Video/audio content
-5. Complex data tables
-
----
-
-## Recommendations for Future Improvements
-
-### High Priority 🔥
-
-1. **`<table>` Support** - Would fix Wikipedia infoboxes
-2. **`<pre>` Formatting** - Monospace code blocks
-3. **Better Link Indicators** - Show external vs internal links
-
-### Medium Priority 💡
-
-1. **Cookie Persistence** - Stay logged into sites
-2. **Form Submit Improvements** - Better form handling
-3. **Download Progress** - More detailed loading feedback
-
-### Nice to Have ✨
-
-1. **Custom Color Schemes** - Light/dark mode toggle
-2. **Font Size Control** - Adjustability
-3. **Bookmarklet** - Quick add current page
-
----
-
-## Final Verdict 🎯
-
-### Overall Rating: ⭐⭐⭐⭐ (4/5 stars)
-
-**TUT is EXCELLENT for its intended purpose**: a fast, keyboard-driven, terminal-based browser for text-focused browsing.
-
-### Phase 10 Async Image Loading: ✅ **SUCCESS**
-
-The async image loading implementation is a **game changer**:
-- UI remains responsive at all times
-- Progressive rendering feels modern and smooth
-- 3x faster than synchronous loading
-- Real performance gains visible on image-heavy sites
-
-### Real Human Feeling
-
-> **"TUT feels like a breath of fresh air in the modern web."**
->
-> It strips away all the bloat and gives you what matters: **content**.
-> The async image loading makes it feel fast and responsive, even
-> on complex pages. For reading news, docs, and articles, it's
-> genuinely enjoyable to use.
->
-> Yes, it has limitations (tables, complex layouts), but for its
-> core use case - **focused, distraction-free reading** - it's
-> fantastic. The vim keybindings and instant response make it feel
-> like a native terminal tool, not a sluggish browser.
->
-> **Would I use it daily?** Yes, for HN, docs, and Wikipedia lookups.
-> **Would I replace Chrome?** No, but that's not the point.
-> **Is it readable?** Absolutely. Better than many terminal browsers.
-
----
-
-## Test Conclusion
-
-✅ **Async image loading works flawlessly in real-world usage**
-✅ **Content is highly readable for text-focused sites**
-✅ **Performance is excellent across all site categories**
-✅ **User experience is smooth and responsive**
-⚠️ **Some limitations remain (tables, complex CSS) - acceptable trade-offs**
-
-**TUT 2.0 with Phase 10 is production-ready for its target audience!** 🚀
-
----
-
-**Testing Completed**: 2025-12-28
-**Next Phase**: Consider table rendering support for even better Wikipedia experience

src/browser.cpp

@@ -97,11 +97,6 @@ public:
     static constexpr int CACHE_MAX_AGE = 300;  // 5分钟缓存
     static constexpr size_t CACHE_MAX_SIZE = 20;  // 最多缓存20个页面
 
-    // 图片下载状态
-    int images_total = 0;
-    int images_loaded = 0;
-    int images_cached = 0;
-
     // 图片缓存
     std::map<std::string, ImageCacheEntry> image_cache;
     static constexpr int IMAGE_CACHE_MAX_AGE = 600;  // 10分钟缓存
@@ -189,8 +184,8 @@ public:
             status_message = current_tree.title.empty() ? url : current_tree.title;
         }
 
-        // 下载图片（异步）
-        queue_images(current_tree);
+        // 下载图片
+        load_images(current_tree);
 
         // 布局计算
         current_layout = layout_engine->layout(current_tree);
@@ -218,9 +213,6 @@ public:
 
     // 启动异步页面加载
     void start_async_load(const std::string& url, bool force_refresh = false) {
-        // 取消任何正在进行的图片下载 (避免访问旧树的节点)
-        http_client.cancel_all_images();
-
         // 检查缓存
         auto cache_it = page_cache.find(url);
         bool use_cache = !force_refresh && cache_it != page_cache.end() &&
@@ -250,8 +242,8 @@ public:
                 history_manager.add(url, current_tree.title);
             }
 
-            // 加载图片（异步）
-            queue_images(current_tree);
+            // 加载图片（仍然同步，可以后续优化）
+            load_images(current_tree);
             current_layout = layout_engine->layout(current_tree);
             return;
         }
@@ -309,81 +301,6 @@ public:
                 default:
                     return false;
             }
-        } else if (loading_state == LoadingState::LOADING_IMAGES) {
-            // 轮询图片下载
-            http_client.poll_image_downloads();
-
-            // 处理已完成的图片
-            auto completed = http_client.get_completed_images();
-            bool need_relayout = false;
-
-            for (auto& task : completed) {
-                images_loaded++;
-
-                if (!task.is_success() || task.data.empty()) {
-                    continue;  // 跳过失败的图片
-                }
-
-                // 解码图片
-                tut::ImageData img_data = tut::ImageRenderer::load_from_memory(task.data);
-                if (img_data.is_valid()) {
-                    // 设置到对应的DomNode
-                    DomNode* img_node = static_cast<DomNode*>(task.user_data);
-
-                    // 验证节点仍然有效 (仍在当前树的images列表中)
-                    bool node_valid = false;
-                    if (img_node) {
-                        for (const auto* node : current_tree.images) {
-                            if (node == img_node) {
-                                node_valid = true;
-                                break;
-                            }
-                        }
-                    }
-
-                    if (node_valid) {
-                        img_node->image_data = img_data;
-                        need_relayout = true;
-
-                        // 添加到缓存
-                        if (image_cache.size() >= IMAGE_CACHE_MAX_SIZE) {
-                            // 移除最老的缓存条目
-                            auto oldest = image_cache.begin();
-                            for (auto it = image_cache.begin(); it != image_cache.end(); ++it) {
-                                if (it->second.timestamp < oldest->second.timestamp) {
-                                    oldest = it;
-                                }
-                            }
-                            image_cache.erase(oldest);
-                        }
-
-                        ImageCacheEntry entry;
-                        entry.image_data = std::move(img_data);
-                        entry.timestamp = std::chrono::steady_clock::now();
-                        image_cache[task.url] = std::move(entry);
-                    }
-                }
-            }
-
-            // 如果有图片完成，重新布局
-            if (need_relayout) {
-                current_layout = layout_engine->layout(current_tree);
-            }
-
-            // 检查是否所有图片都已完成
-            if (http_client.get_pending_image_count() == 0 &&
-                http_client.get_loading_image_count() == 0) {
-                if (images_total > 0) {
-                    status_message = "✓ Loaded " + std::to_string(images_total) + " images";
-                    if (images_cached > 0) {
-                        status_message += " (" + std::to_string(images_cached) + " from cache)";
-                    }
-                }
-                loading_state = LoadingState::IDLE;
-                return false;
-            }
-
-            return true;
         }
 
         return loading_state != LoadingState::IDLE;
@@ -395,11 +312,7 @@ public:
         if (loading_state == LoadingState::LOADING_PAGE) {
             status_message = spinner + " Loading " + extract_host(pending_url) + "...";
         } else if (loading_state == LoadingState::LOADING_IMAGES) {
-            status_message = spinner + " Loading images " + std::to_string(images_loaded) +
-                           "/" + std::to_string(images_total);
-            if (images_cached > 0) {
-                status_message += " (cached: " + std::to_string(images_cached) + ")";
-            }
+            status_message = spinner + " Loading images...";
         }
     }
 
@@ -442,22 +355,17 @@ public:
 
         status_message = current_tree.title.empty() ? pending_url : current_tree.title;
 
-        // 加载图片（异步）
-        queue_images(current_tree);
+        // 加载图片（目前仍同步，可后续优化为异步）
+        load_images(current_tree);
         current_layout = layout_engine->layout(current_tree);
 
-        // 不设置为IDLE，等待图片加载完成
-        // loading_state will be set by poll_loading when images finish
+        loading_state = LoadingState::IDLE;
     }
 
     // 取消加载
     void cancel_loading() {
         if (loading_state != LoadingState::IDLE) {
-            if (loading_state == LoadingState::LOADING_PAGE) {
-                http_client.cancel_async();
-            } else if (loading_state == LoadingState::LOADING_IMAGES) {
-                http_client.cancel_all_images();
-            }
+            http_client.cancel_async();
             loading_state = LoadingState::IDLE;
             status_message = "⚠ Cancelled";
         }
@@ -483,49 +391,72 @@ public:
     }
 
     // 下载并解码页面中的图片
-    // 将图片加入异步下载队列
-    void queue_images(DocumentTree& tree) {
+    void load_images(DocumentTree& tree) {
         if (tree.images.empty()) {
-            loading_state = LoadingState::IDLE;
             return;
         }
 
-        images_cached = 0;
-        images_total = 0;
-        images_loaded = 0;
+        int loaded = 0;
+        int cached = 0;
+        int total = static_cast<int>(tree.images.size());
 
         for (DomNode* img_node : tree.images) {
             if (img_node->img_src.empty()) {
                 continue;
             }
 
-            images_total++;
+            loaded++;
 
             // 检查缓存
             auto cache_it = image_cache.find(img_node->img_src);
             if (cache_it != image_cache.end() && !cache_it->second.is_expired(IMAGE_CACHE_MAX_AGE)) {
                 // 使用缓存的图片
                 img_node->image_data = cache_it->second.image_data;
-                images_cached++;
-                images_loaded++;
+                cached++;
+                status_message = "🖼 Loading image " + std::to_string(loaded) + "/" + std::to_string(total) +
+                                " (cached: " + std::to_string(cached) + ")";
+                draw_screen();
                 continue;
             }
 
-            // 添加到下载队列
-            http_client.add_image_download(img_node->img_src, img_node);
+            // 更新状态
+            status_message = "🖼 Downloading image " + std::to_string(loaded) + "/" + std::to_string(total) + "...";
+            draw_screen();
+
+            // 下载图片
+            auto response = http_client.fetch_binary(img_node->img_src);
+            if (!response.is_success() || response.data.empty()) {
+                continue;  // 跳过失败的图片
+            }
+
+            // 解码图片
+            tut::ImageData img_data = tut::ImageRenderer::load_from_memory(response.data);
+            if (img_data.is_valid()) {
+                img_node->image_data = img_data;
+
+                // 添加到缓存
+                // 限制缓存大小
+                if (image_cache.size() >= IMAGE_CACHE_MAX_SIZE) {
+                    // 移除最老的缓存条目
+                    auto oldest = image_cache.begin();
+                    for (auto it = image_cache.begin(); it != image_cache.end(); ++it) {
+                        if (it->second.timestamp < oldest->second.timestamp) {
+                            oldest = it;
+                        }
+                    }
+                    image_cache.erase(oldest);
+                }
+
+                ImageCacheEntry entry;
+                entry.image_data = std::move(img_data);
+                entry.timestamp = std::chrono::steady_clock::now();
+                image_cache[img_node->img_src] = std::move(entry);
+            }
         }
 
-        // 如果所有图片都在缓存中，直接完成
-        if (http_client.get_pending_image_count() == 0 &&
-            http_client.get_loading_image_count() == 0) {
-            if (images_cached > 0) {
-                status_message = "✓ Loaded " + std::to_string(images_total) + " images (" +
-                               std::to_string(images_cached) + " from cache)";
-            }
-            loading_state = LoadingState::IDLE;
-        } else {
-            loading_state = LoadingState::LOADING_IMAGES;
-            update_loading_status();
+        if (cached > 0) {
+            status_message = "✓ Loaded " + std::to_string(total) + " images (" +
+                           std::to_string(cached) + " from cache)";
         }
     }
 

src/http_client.cpp

@@ -17,15 +17,6 @@ static size_t binary_write_callback(void* contents, size_t size, size_t nmemb, s
     return total_size;
 }
 
-// 内部图片下载任务
-struct InternalImageTask {
-    CURL* easy_handle = nullptr;
-    std::string url;
-    void* user_data = nullptr;
-    std::vector<uint8_t> data;
-    bool is_loading = false;
-};
-
 class HttpClient::Impl {
 public:
     CURL* curl;
@@ -34,20 +25,13 @@ public:
     bool follow_redirects;
     std::string cookie_file;
 
-    // 异步请求相关 (页面)
+    // 异步请求相关
     CURLM* multi_handle = nullptr;
     CURL* async_easy = nullptr;
     AsyncState async_state = AsyncState::IDLE;
     std::string async_response_body;
     HttpResponse async_result;
 
-    // 异步图片下载相关
-    CURLM* image_multi = nullptr;  // 专用于图片的multi handle
-    std::vector<InternalImageTask> pending_images;  // 待下载队列
-    std::vector<InternalImageTask> loading_images;  // 正在下载
-    std::vector<ImageDownloadTask> completed_images;  // 已完成
-    int max_concurrent_images = 3;
-
     Impl() : timeout(30),
              user_agent("TUT-Browser/2.0 (Terminal User Interface Browser)"),
              follow_redirects(true) {
@@ -65,22 +49,12 @@ public:
         if (!multi_handle) {
             throw std::runtime_error("Failed to initialize CURL multi handle");
         }
-
-        // 初始化image multi handle用于图片下载
-        image_multi = curl_multi_init();
-        if (!image_multi) {
-            throw std::runtime_error("Failed to initialize image CURL multi handle");
-        }
     }
 
     ~Impl() {
         // 清理异步请求
         cleanup_async();
-        cleanup_all_images();
 
-        if (image_multi) {
-            curl_multi_cleanup(image_multi);
-        }
         if (multi_handle) {
             curl_multi_cleanup(multi_handle);
         }
@@ -122,46 +96,6 @@ public:
 
         curl_easy_setopt(handle, CURLOPT_ACCEPT_ENCODING, "");
     }
-
-    void cleanup_all_images() {
-        // 清理所有正在加载的图片
-        for (auto& task : loading_images) {
-            if (task.easy_handle) {
-                curl_multi_remove_handle(image_multi, task.easy_handle);
-                curl_easy_cleanup(task.easy_handle);
-            }
-        }
-        loading_images.clear();
-
-        // 清理待下载的图片
-        for (auto& task : pending_images) {
-            if (task.easy_handle) {
-                curl_easy_cleanup(task.easy_handle);
-            }
-        }
-        pending_images.clear();
-        completed_images.clear();
-    }
-
-    // 启动一个图片下载任务
-    void start_image_download(InternalImageTask& task) {
-        task.easy_handle = curl_easy_init();
-        if (!task.easy_handle) {
-            return;  // 跳过失败的任务
-        }
-
-        // 配置请求
-        setup_easy_handle(task.easy_handle, task.url);
-
-        // 设置写回调
-        task.data.clear();
-        curl_easy_setopt(task.easy_handle, CURLOPT_WRITEFUNCTION, binary_write_callback);
-        curl_easy_setopt(task.easy_handle, CURLOPT_WRITEDATA, &task.data);
-
-        // 添加到multi handle
-        curl_multi_add_handle(image_multi, task.easy_handle);
-        task.is_loading = true;
-    }
 };
 
 HttpClient::HttpClient() : pImpl(std::make_unique<Impl>()) {}
@@ -518,114 +452,4 @@ void HttpClient::cancel_async() {
 
 bool HttpClient::is_async_active() const {
     return pImpl->async_state == AsyncState::LOADING;
-}
-
-// ========== 异步图片下载接口 ==========
-
-void HttpClient::add_image_download(const std::string& url, void* user_data) {
-    InternalImageTask task;
-    task.url = url;
-    task.user_data = user_data;
-    pImpl->pending_images.push_back(std::move(task));
-}
-
-void HttpClient::poll_image_downloads() {
-    // 启动新的下载任务，直到达到最大并发数
-    while (!pImpl->pending_images.empty() &&
-           static_cast<int>(pImpl->loading_images.size()) < pImpl->max_concurrent_images) {
-        InternalImageTask task = std::move(pImpl->pending_images.front());
-        pImpl->pending_images.erase(pImpl->pending_images.begin());
-
-        pImpl->start_image_download(task);
-        pImpl->loading_images.push_back(std::move(task));
-    }
-
-    if (pImpl->loading_images.empty()) {
-        return;  // 没有正在下载的任务
-    }
-
-    // 执行非阻塞的multi perform
-    int still_running = 0;
-    CURLMcode mc = curl_multi_perform(pImpl->image_multi, &still_running);
-
-    if (mc != CURLM_OK) {
-        // 发生错误，放弃所有正在下载的任务
-        pImpl->cleanup_all_images();
-        return;
-    }
-
-    // 检查是否有完成的请求
-    int msgs_left = 0;
-    CURLMsg* msg;
-    std::vector<std::pair<CURL*, CURLcode>> to_remove;  // 记录需要移除的handles和结果
-
-    while ((msg = curl_multi_info_read(pImpl->image_multi, &msgs_left))) {
-        if (msg->msg == CURLMSG_DONE) {
-            to_remove.push_back({msg->easy_handle, msg->data.result});
-        }
-    }
-
-    // 处理完成的任务
-    for (const auto& [easy, curl_result] : to_remove) {
-        // 找到对应的任务
-        for (auto it = pImpl->loading_images.begin(); it != pImpl->loading_images.end(); ++it) {
-            if (it->easy_handle == easy) {
-                ImageDownloadTask completed;
-                completed.url = it->url;
-                completed.user_data = it->user_data;
-
-                if (curl_result == CURLE_OK) {
-                    // 获取响应信息
-                    long http_code = 0;
-                    curl_easy_getinfo(easy, CURLINFO_RESPONSE_CODE, &http_code);
-                    completed.status_code = static_cast<int>(http_code);
-
-                    char* content_type = nullptr;
-                    curl_easy_getinfo(easy, CURLINFO_CONTENT_TYPE, &content_type);
-                    if (content_type) {
-                        completed.content_type = content_type;
-                    }
-
-                    completed.data = std::move(it->data);
-                } else {
-                    completed.error_message = curl_easy_strerror(curl_result);
-                    completed.status_code = 0;
-                }
-
-                pImpl->completed_images.push_back(std::move(completed));
-
-                // 清理easy handle
-                curl_multi_remove_handle(pImpl->image_multi, easy);
-                curl_easy_cleanup(easy);
-
-                // 从loading列表中移除
-                pImpl->loading_images.erase(it);
-                break;
-            }
-        }
-    }
-}
-
-std::vector<ImageDownloadTask> HttpClient::get_completed_images() {
-    std::vector<ImageDownloadTask> result = std::move(pImpl->completed_images);
-    pImpl->completed_images.clear();
-    return result;
-}
-
-void HttpClient::cancel_all_images() {
-    pImpl->cleanup_all_images();
-}
-
-int HttpClient::get_pending_image_count() const {
-    return static_cast<int>(pImpl->pending_images.size());
-}
-
-int HttpClient::get_loading_image_count() const {
-    return static_cast<int>(pImpl->loading_images.size());
-}
-
-void HttpClient::set_max_concurrent_images(int max) {
-    if (max > 0 && max <= 10) {  // 限制在1-10之间
-        pImpl->max_concurrent_images = max;
-    }
 }

src/http_client.h

@@ -40,20 +40,6 @@ struct BinaryResponse {
     }
 };
 
-// 异步图片下载任务
-struct ImageDownloadTask {
-    std::string url;
-    void* user_data;  // 用户自定义数据 (例如 DomNode*)
-    std::vector<uint8_t> data;
-    std::string content_type;
-    int status_code = 0;
-    std::string error_message;
-
-    bool is_success() const {
-        return status_code >= 200 && status_code < 300;
-    }
-};
-
 class HttpClient {
 public:
     HttpClient();
@@ -65,22 +51,13 @@ public:
     HttpResponse post(const std::string& url, const std::string& data,
                      const std::string& content_type = "application/x-www-form-urlencoded");
 
-    // 异步请求接口 (页面)
+    // 异步请求接口
     void start_async_fetch(const std::string& url);
     AsyncState poll_async();  // 非阻塞轮询，返回当前状态
     HttpResponse get_async_result();  // 获取结果并重置状态
     void cancel_async();  // 取消当前异步请求
     bool is_async_active() const;  // 是否有活跃的异步请求
 
-    // 异步图片下载接口 (支持多并发)
-    void add_image_download(const std::string& url, void* user_data = nullptr);
-    void poll_image_downloads();  // 非阻塞轮询所有图片下载
-    std::vector<ImageDownloadTask> get_completed_images();  // 获取并移除已完成的图片
-    void cancel_all_images();  // 取消所有图片下载
-    int get_pending_image_count() const;  // 获取待下载图片数量
-    int get_loading_image_count() const;  // 获取正在下载的图片数量
-    void set_max_concurrent_images(int max);  // 设置最大并发数 (默认3)
-
     // 配置
     void set_timeout(long timeout_seconds);
     void set_user_agent(const std::string& user_agent);

test_real_world.sh

@@ -1,143 +0,0 @@
-#!/bin/bash
-# Real-world browser testing script
-# Tests TUT with various website types and provides UX feedback
-
-echo "════════════════════════════════════════════════════════════"
-echo "  TUT Real-World Browser Testing"
-echo "════════════════════════════════════════════════════════════"
-echo ""
-echo "This script will test TUT with various website types:"
-echo ""
-echo "1. News sites (text-heavy, many images)"
-echo "2. Documentation (code blocks, technical content)"
-echo "3. Simple static sites (basic HTML)"
-echo "4. Image galleries (many concurrent images)"
-echo "5. Forums/discussions (mixed content)"
-echo ""
-echo "For each site, we'll evaluate:"
-echo "  • Loading speed and responsiveness"
-echo "  • Image loading behavior"
-echo "  • Content readability"
-echo "  • Navigation smoothness"
-echo "  • Overall user experience"
-echo ""
-echo "════════════════════════════════════════════════════════════"
-echo ""
-
-# Test categories
-declare -A SITES
-
-# Category 1: News/Content sites
-SITES["news_hn"]="https://news.ycombinator.com"
-SITES["news_lobsters"]="https://lobste.rs"
-
-# Category 2: Documentation
-SITES["doc_curl"]="https://curl.se/docs/manpage.html"
-SITES["doc_rust"]="https://doc.rust-lang.org/book/ch01-01-installation.html"
-
-# Category 3: Simple/Static
-SITES["simple_example"]="https://example.com"
-SITES["simple_motherfuckingwebsite"]="https://motherfuckingwebsite.com"
-
-# Category 4: Wikipedia (images + content)
-SITES["wiki_unix"]="https://en.wikipedia.org/wiki/Unix"
-SITES["wiki_web"]="https://en.wikipedia.org/wiki/World_Wide_Web"
-
-# Category 5: Tech blogs
-SITES["blog_lwn"]="https://lwn.net"
-
-echo "Available test sites:"
-echo ""
-echo "News & Content:"
-echo "  1. Hacker News         - ${SITES[news_hn]}"
-echo "  2. Lobsters            - ${SITES[news_lobsters]}"
-echo ""
-echo "Documentation:"
-echo "  3. curl manual         - ${SITES[doc_curl]}"
-echo "  4. Rust Book           - ${SITES[doc_rust]}"
-echo ""
-echo "Simple Sites:"
-echo "  5. Example.com         - ${SITES[simple_example]}"
-echo "  6. Motherfucking Web   - ${SITES[simple_motherfuckingwebsite]}"
-echo ""
-echo "Wikipedia:"
-echo "  7. Unix                - ${SITES[wiki_unix]}"
-echo "  8. World Wide Web      - ${SITES[wiki_web]}"
-echo ""
-echo "Tech News:"
-echo "  9. LWN.net             - ${SITES[blog_lwn]}"
-echo ""
-echo "════════════════════════════════════════════════════════════"
-echo ""
-
-# Function to test a site
-test_site() {
-    local name=$1
-    local url=$2
-
-    echo ""
-    echo "──────────────────────────────────────────────────────────"
-    echo "Testing: $name"
-    echo "URL: $url"
-    echo "──────────────────────────────────────────────────────────"
-    echo ""
-    echo "Starting browser... (Press 'q' to quit and move to next)"
-    echo ""
-
-    ./build/tut "$url"
-
-    echo ""
-    echo "Test completed for: $name"
-    echo ""
-}
-
-# Interactive mode
-echo "Select test mode:"
-echo "  a) Test all sites automatically"
-echo "  m) Manual site selection"
-echo "  q) Quit"
-echo ""
-read -p "Choice: " choice
-
-case $choice in
-    a)
-        echo ""
-        echo "Running automated tests..."
-        echo "Note: Each site will open. Press 'q' to move to next."
-        echo ""
-        sleep 2
-
-        test_site "Hacker News" "${SITES[news_hn]}"
-        test_site "Example.com" "${SITES[simple_example]}"
-        test_site "Wikipedia - Unix" "${SITES[wiki_unix]}"
-        ;;
-    m)
-        echo ""
-        read -p "Enter site number (1-9): " num
-        case $num in
-            1) test_site "Hacker News" "${SITES[news_hn]}" ;;
-            2) test_site "Lobsters" "${SITES[news_lobsters]}" ;;
-            3) test_site "curl manual" "${SITES[doc_curl]}" ;;
-            4) test_site "Rust Book" "${SITES[doc_rust]}" ;;
-            5) test_site "Example.com" "${SITES[simple_example]}" ;;
-            6) test_site "Motherfucking Website" "${SITES[simple_motherfuckingwebsite]}" ;;
-            7) test_site "Wikipedia - Unix" "${SITES[wiki_unix]}" ;;
-            8) test_site "Wikipedia - WWW" "${SITES[wiki_web]}" ;;
-            9) test_site "LWN.net" "${SITES[blog_lwn]}" ;;
-            *) echo "Invalid selection" ;;
-        esac
-        ;;
-    q)
-        echo "Exiting..."
-        exit 0
-        ;;
-    *)
-        echo "Invalid choice"
-        exit 1
-        ;;
-esac
-
-echo ""
-echo "════════════════════════════════════════════════════════════"
-echo "  Testing Complete!"
-echo "════════════════════════════════════════════════════════════"

tests/test_async_images.cpp

@@ -1,122 +0,0 @@
-#include "../src/http_client.h"
-#include <iostream>
-#include <cassert>
-#include <chrono>
-#include <thread>
-
-void test_async_image_downloads() {
-    std::cout << "Testing async image downloads...\n";
-
-    HttpClient client;
-
-    // Add multiple image downloads
-    // Using small test images from httpbin.org
-    const char* test_images[] = {
-        "https://httpbin.org/image/png",
-        "https://httpbin.org/image/jpeg",
-        "https://httpbin.org/image/webp"
-    };
-
-    // Add images to queue
-    for (int i = 0; i < 3; i++) {
-        client.add_image_download(test_images[i], (void*)(intptr_t)i);
-        std::cout << "  Queued: " << test_images[i] << "\n";
-    }
-
-    std::cout << "  Pending: " << client.get_pending_image_count() << "\n";
-    assert(client.get_pending_image_count() == 3);
-
-    // Poll until all images are downloaded
-    int iterations = 0;
-    int max_iterations = 200;  // 10 seconds max (50ms * 200)
-
-    while ((client.get_pending_image_count() > 0 ||
-            client.get_loading_image_count() > 0) &&
-           iterations < max_iterations) {
-        client.poll_image_downloads();
-
-        // Check for completed images
-        auto completed = client.get_completed_images();
-        for (const auto& img : completed) {
-            std::cout << "  Downloaded: " << img.url
-                     << " (status: " << img.status_code
-                     << ", size: " << img.data.size() << " bytes)\n";
-        }
-
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
-        iterations++;
-    }
-
-    std::cout << "  Completed after " << iterations << " iterations\n";
-    std::cout << "  Final state - Pending: " << client.get_pending_image_count()
-             << ", Loading: " << client.get_loading_image_count() << "\n";
-
-    std::cout << "✓ Async image download test passed!\n\n";
-}
-
-void test_image_cancellation() {
-    std::cout << "Testing image download cancellation...\n";
-
-    HttpClient client;
-
-    // Add images
-    client.add_image_download("https://httpbin.org/image/png", nullptr);
-    client.add_image_download("https://httpbin.org/image/jpeg", nullptr);
-
-    std::cout << "  Queued 2 images\n";
-
-    // Start downloads
-    client.poll_image_downloads();
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-
-    // Cancel all
-    std::cout << "  Cancelling all downloads\n";
-    client.cancel_all_images();
-
-    assert(client.get_pending_image_count() == 0);
-    assert(client.get_loading_image_count() == 0);
-
-    std::cout << "✓ Image cancellation test passed!\n\n";
-}
-
-void test_concurrent_limit() {
-    std::cout << "Testing concurrent download limit...\n";
-
-    HttpClient client;
-    client.set_max_concurrent_images(2);
-
-    // Add 5 images
-    for (int i = 0; i < 5; i++) {
-        client.add_image_download("https://httpbin.org/delay/1", nullptr);
-    }
-
-    std::cout << "  Queued 5 images with max_concurrent=2\n";
-    assert(client.get_pending_image_count() == 5);
-
-    // Start downloads
-    client.poll_image_downloads();
-
-    // Should have max 2 loading at a time
-    int loading = client.get_loading_image_count();
-    std::cout << "  Loading: " << loading << " (should be <= 2)\n";
-    assert(loading <= 2);
-
-    client.cancel_all_images();
-    std::cout << "✓ Concurrent limit test passed!\n\n";
-}
-
-int main() {
-    std::cout << "=== Async Image Download Tests ===\n\n";
-
-    try {
-        test_async_image_downloads();
-        test_image_cancellation();
-        test_concurrent_limit();
-
-        std::cout << "=== All tests passed! ===\n";
-        return 0;
-    } catch (const std::exception& e) {
-        std::cerr << "Test failed: " << e.what() << "\n";
-        return 1;
-    }
-}

tests/test_image_minimal.cpp

@@ -1,42 +0,0 @@
-#include "../src/http_client.h"
-#include <iostream>
-#include <thread>
-#include <chrono>
-
-int main() {
-    std::cout << "=== Minimal Async Image Test ===\n";
-
-    try {
-        HttpClient client;
-        std::cout << "1. Client created\n";
-
-        client.add_image_download("https://httpbin.org/image/png", nullptr);
-        std::cout << "2. Image queued\n";
-        std::cout << "   Pending: " << client.get_pending_image_count() << "\n";
-
-        std::cout << "3. First poll...\n";
-        client.poll_image_downloads();
-        std::cout << "   After poll - Pending: " << client.get_pending_image_count()
-                 << ", Loading: " << client.get_loading_image_count() << "\n";
-
-        std::cout << "4. Wait a bit...\n";
-        std::this_thread::sleep_for(std::chrono::milliseconds(500));
-
-        std::cout << "5. Second poll...\n";
-        client.poll_image_downloads();
-        std::cout << "   After poll - Pending: " << client.get_pending_image_count()
-                 << ", Loading: " << client.get_loading_image_count() << "\n";
-
-        std::cout << "6. Get completed...\n";
-        auto completed = client.get_completed_images();
-        std::cout << "   Completed: " << completed.size() << "\n";
-
-        std::cout << "7. Destroying client...\n";
-    } catch (const std::exception& e) {
-        std::cerr << "ERROR: " << e.what() << "\n";
-        return 1;
-    }
-
-    std::cout << "8. Test completed successfully!\n";
-    return 0;
-}

tests/test_simple_image.cpp

@@ -1,23 +0,0 @@
-#include "../src/http_client.h"
-#include <iostream>
-
-int main() {
-    std::cout << "Testing basic image download...\n";
-
-    try {
-        HttpClient client;
-        std::cout << "Client created\n";
-
-        client.add_image_download("https://httpbin.org/image/png", nullptr);
-        std::cout << "Image queued\n";
-        std::cout << "Pending: " << client.get_pending_image_count() << "\n";
-
-        std::cout << "Client will be destroyed\n";
-    } catch (const std::exception& e) {
-        std::cerr << "Error: " << e.what() << "\n";
-        return 1;
-    }
-
-    std::cout << "Test completed successfully\n";
-    return 0;
-}